{"version":3,"file":"static/js/15.d1cd2325.chunk.js","mappings":"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","sources":["../node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","../node_modules/framer-motion/dist/es/events/event-info.mjs","../node_modules/framer-motion/dist/es/events/use-dom-event.mjs","../node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","../node_modules/framer-motion/dist/es/events/utils.mjs","../node_modules/framer-motion/dist/es/gestures/PanSession.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","../node_modules/framer-motion/dist/es/render/utils/types.mjs","../node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","../node_modules/framer-motion/dist/es/projection/utils/measure.mjs","../node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","../node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","../node_modules/framer-motion/dist/es/motion/features/drag.mjs","../node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","../node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","../node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","../node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","../node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","../node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","../node_modules/framer-motion/dist/es/render/utils/setters.mjs","../node_modules/framer-motion/dist/es/render/utils/animation.mjs","../node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","../node_modules/framer-motion/dist/es/motion/features/animations.mjs","../node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","../node_modules/framer-motion/dist/es/motion/features/gestures.mjs","../node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","../node_modules/framer-motion/dist/es/render/utils/lifecycles.mjs","../node_modules/framer-motion/dist/es/render/index.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","../node_modules/framer-motion/dist/es/render/html/visual-element.mjs","../node_modules/framer-motion/dist/es/render/svg/visual-element.mjs","../node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","../node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","../node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","../node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","../node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["function isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    var hasTouches = !!event.touches;\n    return hasTouches;\n}\n\nexport { isMouseEvent, isTouchEvent };\n","import { isTouchEvent } from '../gestures/utils/event-type.mjs';\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return function (event) {\n        var isMouseEvent = event instanceof MouseEvent;\n        var isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nvar defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    var primaryTouch = e.touches[0] || e.changedTouches[0];\n    var point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }\n    var listener = function (event) {\n        return handler(event, extractEventInfo(event));\n    };\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\nexport { extractEventInfo, wrapHandler };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options) {\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler, options); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\nexport { addDomEvent, useDomEvent };\n","import { addDomEvent, useDomEvent } from './use-dom-event.mjs';\nimport { wrapHandler } from './event-info.mjs';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.mjs';\n\nvar mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nvar touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nexport { addPointerEvent, usePointerEvent };\n","import { isBrowser } from '../utils/is-browser.mjs';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { distance, pipe } from 'popmotion';\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = getFrameData().timestamp;\n            _this.history.push(__assign(__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync.update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = getFrameData().timestamp;\n        this.history = [__assign(__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nexport { PanSession };\n","function createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","import { __read } from 'tslib';\nimport { clamp, mix, progress } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, _a, elastic) {\n    var min = _a.min, max = _a.max;\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? mix(min, point, elastic.min) : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic ? mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, _a) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    return {\n        x: calcRelativeAxisConstraints(layoutBox.x, left, right),\n        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),\n    };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative axis\n */\nfunction calcViewportAxisConstraints(layoutAxis, constraintsAxis) {\n    var _a;\n    var min = constraintsAxis.min - layoutAxis.min;\n    var max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        _a = __read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","var AnimationType;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nexport { AnimationType };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.y;\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","import { __assign } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = __assign(__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return __assign(__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n","var makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nexport { makeRenderlessComponent };\n","import { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @internalremarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = useRef(null);\n    var transformPagePoint = useContext(MotionConfigContext).transformPagePoint;\n    var handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: function (event, info) {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    useEffect(function () {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint: transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(function () { return panSession.current && panSession.current.end(); });\n}\n\nexport { usePanGesture };\n","import { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\nexport { useDrag };\n","import { useContext, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useId } from '../../utils/use-id.mjs';\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    var context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    // Replace with useId when released in React\n    var id = useId();\n    useEffect(function () { return register(id); }, []);\n    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id); };\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","import { px } from 'style-value-types';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        var x = pixelsToPercent(latest, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\n","import { __rest, __assign, __read } from 'tslib';\nimport { invariant } from 'hey-listen';\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    var match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    var _a = __read(match, 3), token = _a[1], fallback = _a[2];\n    return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n    if (depth === void 0) { depth = 1; }\n    invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\".concat(current, \"\\\". This may indicate a circular fallback dependency.\"));\n    var _a = __read(parseCSSVariable(current), 2), token = _a[0], fallback = _a[1];\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    var resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariable(fallback)) {\n        // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n        return getVariableValue(fallback, element, depth + 1);\n    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n    var _b;\n    var target = __rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof Element))\n        return { target: target, transitionEnd: transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = __assign({}, transitionEnd);\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.forEachValue(function (value) {\n        var current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        var resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (var key in target) {\n        var current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        var resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd)\n            (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : (transitionEnd[key] = current);\n    }\n    return { target: target, transitionEnd: transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","import { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = complex.createTransformer(latest);\n        var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        var xScale = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = mix(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        var output = template(shadow);\n        if (containsCSSVariables) {\n            var i_1 = 0;\n            output = output.replace(varToken, function () {\n                var cssVariable = cssVariables[i_1];\n                i_1++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nexport { correctBoxShadow };\n","import { __extends, __assign, __read } from 'tslib';\nimport sync from 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/create-projection-node.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    __extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(__assign(__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync.postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default.Component));\nfunction MeasureLayout(props) {\n    var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, __assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    var prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (var i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nvar isNumericalString = function (v) { return /^\\-?\\d*\\.?\\d+$/.test(v); };\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nexport { isZeroValueString };\n","/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\nexport { testValueType };\n","import { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n    return dimensionValueTypes.find(testValueType(v));\n};\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\nexport { auto };\n","import { __spreadArray, __read } from 'tslib';\nimport { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = __spreadArray(__spreadArray([], __read(dimensionValueTypes), false), [color, complex], false);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\n\nexport { findValueType };\n","import { __rest, __assign, __spreadArray, __read } from 'tslib';\nimport { complex } from 'style-value-types';\nimport { isNumericalString } from '../../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    var resolved = resolveVariant(visualElement, definition);\n    var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = __rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = __assign(__assign({}, target), transitionEnd);\n    for (var key in target) {\n        var value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    var reversedLabels = __spreadArray([], __read(variantLabels), false).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\n        if (typeof value === \"string\" &&\n            (isNumericalString(value) || isZeroValueString(value))) {\n            // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n            value = parseFloat(value);\n        }\n        else if (!findValueType(value) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : (_d[key] = value);\n        visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    var valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a, _b;\n    var origin = {};\n    for (var key in target) {\n        origin[key] =\n            (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","import { __read, __rest, __assign } from 'tslib';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { setTarget } from './setters.mjs';\nimport { resolveVariant } from './variants.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\n\n/**\n * @internal\n */\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return Promise.resolve(); };\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return Promise.resolve(); };\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    var when = transition.when;\n    if (when) {\n        var _c = __read(when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n    var _b;\n    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;\n    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = __rest(_e, [\"transition\", \"transitionEnd\"]);\n    if (transitionOverride)\n        transition = transitionOverride;\n    var animations = [];\n    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n    for (var key in target) {\n        var value = visualElement.getValue(key);\n        var valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        var valueTransition = __assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = __assign(__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, __assign(__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.forEachValue(function (value) { return value.stop(); });\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation(_a, key) {\n    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;\n    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\n","import { __spreadArray, __read, __assign, __rest } from 'tslib';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { animateVisualElement } from './animation.mjs';\nimport { AnimationType } from './types.mjs';\nimport { isVariantLabels, resolveVariant, isVariantLabel } from './variants.mjs';\n\nvar variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.InView,\n    AnimationType.Focus,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Exit,\n];\nvar reversePriorityOrder = __spreadArray([], __read(variantPriorityOrder), false).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = __rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = __assign(__assign(__assign({}, acc), target), transitionEnd);\n        }\n        return acc;\n    };\n    function isAnimated(key) {\n        return allAnimatedKeys[key] !== undefined;\n    }\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        var _a;\n        var props = visualElement.getProps();\n        var context = visualElement.getVariantContext(true) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        var animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        var removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        var encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        var removedVariantIndex = Infinity;\n        var _loop_1 = function (i) {\n            var type = reversePriorityOrder[i];\n            var typeState = state[type];\n            var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            var propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            var activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            var isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = __assign({}, encounteredKeys);\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                return \"continue\";\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            var variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            var definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = __assign(__assign({}, prevResolvedValues), resolvedValues);\n            var markToAnimate = function (key) {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (var key in allKeys) {\n                var next = resolvedValues[key];\n                var prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = __assign(__assign({}, encounteredKeys), resolvedValues);\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push.apply(animations, __spreadArray([], __read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: __assign({ type: type }, options),\n                }); })), false));\n            }\n        };\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = __assign({}, encounteredKeys);\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            var fallbackAnimation_1 = {};\n            removedKeys.forEach(function (key) {\n                var fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation_1[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation_1 });\n        }\n        var shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[AnimationType.Animate] = createTypeState(true),\n        _a[AnimationType.InView] = createTypeState(),\n        _a[AnimationType.Hover] = createTypeState(),\n        _a[AnimationType.Tap] = createTypeState(),\n        _a[AnimationType.Drag] = createTypeState(),\n        _a[AnimationType.Focus] = createTypeState(),\n        _a[AnimationType.Exit] = createTypeState(),\n        _a;\n}\n\nexport { checkVariantsDidChange, createAnimationState, variantPriorityOrder };\n","import { __read } from 'tslib';\nimport { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { createAnimationState } from '../../render/utils/animation-state.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar animations = {\n    animation: makeRenderlessComponent(function (_a) {\n        var visualElement = _a.visualElement, animate = _a.animate;\n        /**\n         * We dynamically generate the AnimationState manager as it contains a reference\n         * to the underlying animation library. We only want to load that if we load this,\n         * so people can optionally code split it out using the `m` component.\n         */\n        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            useEffect(function () { return animate.subscribe(visualElement); }, [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent(function (props) {\n        var custom = props.custom, visualElement = props.visualElement;\n        var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n        var presenceContext = useContext(PresenceContext);\n        useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n","import { isMouseEvent } from './utils/event-type.mjs';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined);\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined);\n}\n\nexport { useHoverGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nvar isNodeOrChild = function (parent, child) {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","import { __rest, __assign } from 'tslib';\n\n/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nvar observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = __rest(_a, [\"root\"]);\n    var lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    var rootObservers = observers.get(lookupRoot);\n    var key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, __assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import process from '../../../utils/process.mjs';\nimport { useRef, useEffect } from 'react';\nimport { AnimationType } from '../../../render/utils/types.mjs';\nimport { warnOnce } from '../../../utils/warn-once.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nexport { useViewport };\n","import { useFocusGesture } from '../../gestures/use-focus-gesture.mjs';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.mjs';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.mjs';\nimport { useViewport } from './viewport/use-viewport.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nexport { gestureAnimations };\n","import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n    var onTap = _a.onTap, onTapStart = _a.onTapStart, onTapCancel = _a.onTapCancel, whileTap = _a.whileTap, visualElement = _a.visualElement;\n    var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    var isPressing = useRef(false);\n    var cancelPointerEndListeners = useRef(null);\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.getInstance(), event.target)\n            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)\n            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        var _a;\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp), addPointerEvent(window, \"pointercancel\", onPointerCancel));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n","import { AnimationType } from '../render/utils/types.mjs';\nimport { useDomEvent } from '../events/use-dom-event.mjs';\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n    var whileFocus = _a.whileFocus, visualElement = _a.visualElement;\n    var onFocus = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nexport { useFocusGesture };\n","import { __spreadArray, __read } from 'tslib';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, __spreadArray([], __read(args), false));\n        };\n    });\n    return lifecycles;\n}\n\nexport { createLifecycles };\n","import { __assign, __spreadArray, __read } from 'tslib';\nimport sync, { cancelSync } from 'framesync';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { variantPriorityOrder } from './utils/animation-state.mjs';\nimport { createLifecycles } from './utils/lifecycles.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.mjs';\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender\n         */\n        var lifecycles = createLifecycles();\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        var prevMotionValues = {};\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = __assign({}, latestValues);\n        // Internal methods ========================\n        /**\n         * On mount, this will be hydrated with a callback to disconnect\n         * this visual element from its parent on unmount.\n         */\n        var removeFromVariantTree;\n        /**\n         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync.update(update, false, true);\n            });\n            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n            valueSubscriptions.set(key, function () {\n                removeOnChange();\n                removeOnRenderRequest();\n            });\n        }\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        var initialMotionValues = scrapeMotionValuesFromProps(props);\n        for (var key in initialMotionValues) {\n            var value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        var isControllingVariants = checkIfControllingVariants(props);\n        var isVariantNode = checkIfVariantNode(props);\n        var element = __assign(__assign({ treeType: treeType, \n            /**\n             * This is a mirror of the internal instance prop, which keeps\n             * VisualElement type-compatible with React's RefObject.\n             */\n            current: null, \n            /**\n             * The depth of this visual element within the visual element tree.\n             */\n            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), \n            /**\n             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by the projection tree, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                cancelSync.update(update);\n                cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\n            }, \n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () {\n                        return closestVariantNode.variantChildren.delete(child);\n                    };\n                }\n            }, sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\n            }, \n            /**\n             * Make a target animatable by Popmotion. For instance, if we're\n             * trying to animate width from 100px to 100vw we need to measure 100vw\n             * in pixels to determine what we really need to animate to. This is also\n             * pluggable to support Framer's custom value types like Color,\n             * and CSS variables.\n             */\n            makeTargetAnimatable: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\n            }, \n            /**\n             * Measure the current viewport box with or without transforms.\n             * Only measures axis-aligned boxes, rotate and skew must be manually\n             * removed with a re-render to work.\n             */\n            measureViewportBox: function () {\n                return measureViewportBox(instance, props);\n            }, \n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            }, \n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \n            /**\n             * If we're trying to animate to a previously unencountered value,\n             * we need to check for it in our state and as a last resort read it\n             * directly from the instance (which might have performance implications).\n             */\n            readValue: function (key) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\n            }, \n            /**\n             * Set the base target to later animate back to. This is currently\n             * only hydrated on creation and when we first read a value.\n             */\n            setBaseTarget: function (key, value) {\n                baseTarget[key] = value;\n            }, \n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            }, \n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync.render(render, false, true);\n            }, \n            /**\n             * Synchronously fire render. It's prefered that we batch renders but\n             * in many circumstances, like layout measurement, we need to run this\n             * synchronously. However in those instances other measures should be taken\n             * to batch reads/writes.\n             */\n            syncRender: render, \n            /**\n             * Update the provided props. Ensure any newly-added motion values are\n             * added to our map, old ones removed, and listeners updated.\n             */\n            setProps: function (newProps) {\n                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            } });\n        return element;\n    };\n};\nvar variantProps = __spreadArray([\"initial\"], __read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\n\nexport { visualElement };\n","import { __assign, __read } from 'tslib';\nimport { number, px } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from 'hey-listen';\nimport { transformProps } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\n\nvar positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nvar isPositionalKey = function (key) { return positionalKeys.has(key); };\nvar hasPositionalKey = function (target) {\n    return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nvar isNumOrPxType = function (v) {\n    return v === number || v === px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n    return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) {\n    return function (_bbox, _a) {\n        var transform = _a.transform;\n        if (transform === \"none\" || !transform)\n            return 0;\n        var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n        if (matrix3d) {\n            return getPosFromMatrix(matrix3d[1], pos3);\n        }\n        else {\n            var matrix = transform.match(/^matrix\\((.+)\\)$/);\n            if (matrix) {\n                return getPosFromMatrix(matrix[1], pos2);\n            }\n            else {\n                return 0;\n            }\n        }\n    };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display;\n    var origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach(function (key) {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        var value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = __assign({}, target);\n    transitionEnd = __assign({}, transitionEnd);\n    var targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    var removedTransformValues = [];\n    var hasAttemptedToRemoveTransformValues = false;\n    var changedValueTypeKeys = [];\n    targetPositionalKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        var from = origin[key];\n        var fromType = findDimensionValueType(from);\n        var to = target[key];\n        var toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            var numKeyframes = to.length;\n            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                var current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\n            }\n            else {\n                // If we're going to do value conversion via DOM measurements, we first\n                // need to remove non-positional transform values that could affect the bbox measurements.\n                if (!hasAttemptedToRemoveTransformValues) {\n                    removedTransformValues =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = __read(_a, 2), key = _b[0], value = _b[1];\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.syncRender();\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\n}\n\nexport { BoundingBoxDimension, positionalValues, unitConversion };\n","import { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    var _a;\n    for (var key in next) {\n        var nextValue = next[key];\n        var prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                var existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","import { __rest, __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.mjs';\nimport { isTransformProp } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle(domElement);\n            return ((isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    },\n    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return __assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nexport { getComputedStyle, htmlConfig, htmlVisualElement };\n","import { __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { htmlConfig } from '../html/visual-element.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { isTransformProp } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\n\nvar svgVisualElement = visualElement(__assign(__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    }, readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nexport { svgVisualElement };\n","import { __assign } from 'tslib';\nimport { animations } from '../../motion/features/animations.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\n\n/**\n * @public\n */\nvar domAnimation = __assign(__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\nexport { domAnimation };\n","import { htmlVisualElement } from '../html/visual-element.mjs';\nimport { svgVisualElement } from '../svg/visual-element.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { createProjectionNode } from './create-projection-node.mjs';\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) {\n        ref.addEventListener(\"resize\", notify, { passive: true });\n        return function () { return ref.removeEventListener(\"resize\", notify); };\n    },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { __assign } from 'tslib';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { layoutFeatures } from '../../motion/features/layout/index.mjs';\nimport { domAnimation } from './features-animation.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\n/**\n * @public\n */\nvar domMax = __assign(__assign(__assign(__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\nexport { domMax };\n"],"names":["isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","e","pointType","point","changedTouches","x","y","pointFromMouse","extractEventInfo","wrapHandler","handler","shouldFilterPrimaryPointer","eventHandler","listener","button","addDomEvent","target","eventName","options","addEventListener","removeEventListener","useDomEvent","ref","useEffect","element","current","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","isBrowser","window","onpointerdown","ontouchstart","onmousedown","addPointerEvent","usePointerEvent","PanSession","handlers","_a","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","distance","offset","timestamp","getFrameData","push","__assign","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","sync","end","onEnd","onSessionEnd","panInfo","length","initialInfo","onSessionStart","removeListeners","pipe","prototype","updateHandlers","cancelSync","subtractPoint","a","b","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","i","timestampedPoint","lastPoint","secondsToMilliseconds","time","currentVelocity","Infinity","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","calcRelativeAxisConstraints","axis","min","max","undefined","calcViewportAxisConstraints","layoutAxis","constraintsAxis","__read","AnimationType","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","convertBoundingBoxToBox","top","left","right","bottom","measureViewportBox","instance","topLeft","bottomRight","transformBoxPoints","getBoundingClientRect","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","originPoint","constraints","hasMutatedConstraints","elastic","createBox","start","originEvent","_c","snapToCursor","isPresent","panSession","stopAnimation","_b","getProps","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","eachAxis","getAxisMotionValue","get","percent","measuredAxis","layout","actual","calcLength","parseFloat","animationState","setActive","Drag","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","Math","abs","getCurrentDirection","updateAxis","syncRender","stop","getTransformPagePoint","cancel","startAnimation","onDragEnd","_point","shouldDrag","axisValue","next","mix","applyConstraints","set","dragConstraints","prevConstraints","isRefObject","resolveRefConstraints","layoutBox","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","invariant","constraintsBox","rootProjectionNode","viewportBox","scroll","translateAxis","measurePageBox","root","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","transition","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","Promise","all","then","dragKey","toUpperCase","externalMotionValue","getValue","initial","scalePositionWithinConstraints","boxProgress","latest","source","origin","sourceLength","targetLength","progress","clamp","calcOrigin","transformTemplate","getInstance","style","transform","updateScroll","updateLayout","addListeners","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","hasLayoutChanged","motionValue","translate","props","_d","_e","_f","makeRenderlessComponent","hook","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","useContext","MotionConfigContext","useUnmountEffect","groupDragControls","dragControls","useConstant","subscribe","usePresence","context","PresenceContext","onExitComplete","register","id","useId","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","concat","isCSSVariable","value","startsWith","cssVariableRegex","getVariableValue","depth","match","exec","parseCSSVariable","token","fallback","resolved","getComputedStyle","getPropertyValue","trim","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","replace","shadow","complex","template","xScale","scale","yScale","averageScale","output","i_1","cssVariable","MeasureLayoutWithContext","_super","apply","arguments","__extends","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","addScaleCorrector","defaultScaleCorrectors","group","add","didUpdate","safeToRemove","setOptions","globalProjectionState","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","componentDidUpdate","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","render","React__default","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","SwitchLayoutGroupContext","shallowCompare","prev","Array","isArray","prevLength","isZeroValueString","v","test","testValueType","dimensionValueTypes","number","degrees","vw","vh","parse","findDimensionValueType","find","valueTypes","__spreadArray","color","findValueType","setMotionValue","key","hasValue","addValue","setTarget","definition","resolveVariant","makeTargetAnimatable","transitionEnd","__rest","resolveFinalValueInKeyframes","getOriginFromTransition","from","animateVariant","variant","custom","getDefaultTransition","transitionOverride","getAnimation","animateTarget","resolve","getChildAnimations","variantChildren","size","forwardDelay","delayChildren","staggerChildren","staggerDirection","animations","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","forEach","child","delay","notifyAnimationComplete","animateChildren","when","first","last","animationTypeState","getState","valueTarget","shouldBlockAnimation","valueTransition","shouldReduceMotion","isTransformProp","animation","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","hasOwnProperty","variantPriorityOrder","Animate","InView","Focus","Hover","Tap","Exit","reversePriorityOrder","reverse","numAnimationTypes","animateList","map","notifyAnimationStart","resolvedDefinition","animateVisualElement","createAnimationState","animate","state","createTypeState","createState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","getVariantContext","removedKeys","Set","encounteredKeys","removedVariantIndex","_loop_1","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isActive","isInherited","manuallyAnimateOnMount","prevProp","isAnimationControls","variantDidChange","isVariantLabels","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","delete","isKeyframesTarget","has","blockInitialAnimation","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","isAnimated","setAnimateFunction","makeAnimator","exit","presenceContext","createHoverEvent","callback","isNodeOrChild","parent","parentElement","observerCallbacks","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","thresholdNames","some","useIntersectionObserver","shouldObserve","rootMargin","margin","amount","once","threshold","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","requestAnimationFrame","gestureAnimations","inView","whileInView","viewport","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","removePointerEndListener","call","checkPointerEnd","onPointerUp","onPointerCancel","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","names","BoundingBoxDimension","treeType","build","renderInstance","readValueFromInstance","removeValueFromRenderState","scrapeMotionValuesFromProps","presenceId","visualState","removeFromVariantTree","isMounted","latestValues","renderState","lifecycles","managers","SubscriptionManager","propSubscriptions","clearAllListeners","manager","clear","updatePropListeners","on","propListener","args","_i","notify","createLifecycles","values","Map","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","update","notifyUpdate","bindToMotionValue","removeOnChange","onChange","latestValue","onUpdate","removeOnRenderRequest","onRenderRequest","scheduleRender","initialMotionValues","isMotionValue","isControllingVariants","checkIfControllingVariants","isVariantNode","checkIfVariantNode","children","isVisible","mount","newInstance","addVariantChild","setProps","unmount","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","getLatestValues","setVisibility","visibility","canMutate","removeValue","defaultValue","forEachValue","readValue","setBaseTarget","newProps","nextValue","prevValue","existingValue","hasAnimated","updateMotionValuesFromProps","getVariant","variants","startAtParent","context_1","numVariantProps","name_1","variantProps","positionalKeys","isPositionalKey","setAndResetVelocity","to","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","transformProps","positionalValues","width","paddingLeft","paddingRight","height","paddingTop","paddingBottom","checkAndConvertChangedValueTypes","targetPositionalKeys","Object","keys","filter","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","targetBbox","convertChangedValueTypes","unitConversion","hasPositionalKey","parseDomVariant","Element","resolveCSSVariables","htmlConfig","domElement","defaultType","getDefaultValueType","default","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","vars","transformValues","getOrigin","newValueKeys","numNewValues","targetValue","getAnimatableNone","checkTargetForNewValues","parsed","buildHTMLStyles","renderHTML","htmlVisualElement","svgVisualElement","camelCaseAttributes","camelToDash","getAttribute","_element","buildSVGAttrs","renderSVG","domAnimation","renderer","Component","isSVGComponent","enableHardwareAcceleration","DocumentProjectionNode","createProjectionNode","attachResizeListener","passive","measureScroll","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","defaultParent","documentNode","layoutScroll","domMax","projectionNodeConstructor"],"sourceRoot":""}