{"version":3,"file":"static/js/5891.26886b19.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/utils/time-conversion.mjs","../node_modules/framer-motion/dist/es/events/use-dom-event.mjs","../node_modules/framer-motion/dist/es/events/utils.mjs","../node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","../node_modules/framer-motion/dist/es/utils/distance.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/projection/geometry/delta-calc.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/models.mjs","../node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","../node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","../node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","../node_modules/framer-motion/dist/es/projection/utils/measure.mjs","../node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","../node_modules/framer-motion/dist/es/animation/waapi/easing.mjs","../node_modules/framer-motion/dist/es/animation/waapi/create-accelerated-animation.mjs","../node_modules/framer-motion/dist/es/animation/waapi/index.mjs","../node_modules/framer-motion/dist/es/utils/delay.mjs","../node_modules/framer-motion/dist/es/animation/create-instant-animation.mjs","../node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","../node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","../node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","../node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","../node_modules/framer-motion/dist/es/animation/waapi/supports.mjs","../node_modules/framer-motion/dist/es/animation/index.mjs","../node_modules/framer-motion/dist/es/animation/utils/keyframes.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/inertia.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/resolve-dynamic-variants.mjs","../node_modules/framer-motion/dist/es/render/utils/setters.mjs","../node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","../node_modules/framer-motion/dist/es/animation/optimized-appear/store-id.mjs","../node_modules/framer-motion/dist/es/animation/optimized-appear/handoff.mjs","../node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.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/dom/utils/unit-conversion.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","../node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","../node_modules/framer-motion/dist/es/render/VisualElement.mjs","../node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","../node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","../node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","../node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","../node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","../node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","../node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","../node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","../node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","../node_modules/framer-motion/dist/es/projection/shared/stack.mjs","../node_modules/framer-motion/dist/es/projection/styles/transform.mjs","../node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","../node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","../node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","../node_modules/framer-motion/dist/es/animation/animate.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    const 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 (event) => {\n        const isMouseEvent = event instanceof MouseEvent;\n        const isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nconst defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType = \"page\") {\n    const primaryTouch = e.touches[0] || e.changedTouches[0];\n    const point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType = \"page\") {\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType = \"page\") {\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nconst wrapHandler = (handler, shouldFilterPrimaryPointer = false) => {\n    const listener = (event) => handler(event, extractEventInfo(event));\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\nexport { extractEventInfo, wrapHandler };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nconst secondsToMilliseconds = (seconds) => seconds * 1000;\n\nexport { secondsToMilliseconds };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\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(() => {\n        const 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 { 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.\nconst supportsPointerEvents = () => isBrowser && window.onpointerdown === null;\nconst supportsTouchEvents = () => isBrowser && window.ontouchstart === null;\nconst supportsMouseEvents = () => isBrowser && window.onmousedown === null;\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","import { addDomEvent, useDomEvent } from './use-dom-event.mjs';\nimport { wrapHandler } from './event-info.mjs';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.mjs';\n\nconst 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};\nconst 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","const distance = (a, b) => Math.abs(a - b);\nfunction distance2D(a, b) {\n    // Multi-dimensional\n    const xDelta = distance(a.x, b.x);\n    const yDelta = distance(a.y, b.y);\n    return Math.sqrt(xDelta ** 2 + yDelta ** 2);\n}\n\nexport { distance, distance2D };\n","import { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport { sync, cancelSync } from '../frameloop/index.mjs';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { distance2D } from '../utils/distance.mjs';\nimport { frameData } from '../frameloop/data.mjs';\n\n/**\n * @internal\n */\nclass PanSession {\n    constructor(event, handlers, { 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 = () => {\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const info = getPanInfo(this.lastMoveEventInfo, this.history);\n            const 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            const isDistancePastThreshold = distance2D(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            const { point } = info;\n            const { timestamp } = frameData;\n            this.history.push({ ...point, timestamp });\n            const { onStart, onMove } = this.handlers;\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 = (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 = (event, info) => {\n            this.end();\n            const { onEnd, onSessionEnd } = this.handlers;\n            const 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        const info = extractEventInfo(event);\n        const initialInfo = transformPoint(info, this.transformPagePoint);\n        const { point } = initialInfo;\n        const { timestamp } = frameData;\n        this.history = [{ ...point, timestamp }];\n        const { onSessionStart } = handlers;\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    updateHandlers(handlers) {\n        this.handlers = handlers;\n    }\n    end() {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    }\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({ point }, history) {\n    return {\n        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    let i = history.length - 1;\n    let timestampedPoint = null;\n    const 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    const time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    const 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    let lock = null;\n    return () => {\n        const openLock = () => {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nconst globalHorizontalLock = createLock(\"dragHorizontal\");\nconst globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    let lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        const openHorizontal = globalHorizontalLock();\n        const openVertical = globalVerticalLock();\n        if (openHorizontal && openVertical) {\n            lock = () => {\n                openHorizontal();\n                openVertical();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal)\n                openHorizontal();\n            if (openVertical)\n                openVertical();\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    const openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","import { mix } from '../../utils/mix.mjs';\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target = 0, maxDistance = 0.01) {\n    return Math.abs(value - target) <= maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin = 0.5) {\n    delta.origin = origin;\n    delta.originPoint = mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","import { progress } from '../../../utils/progress.mjs';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { mix } from '../../../utils/mix.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, { min, max }, elastic) {\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, { top, left, bottom, 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    let min = constraintsAxis.min - layoutAxis.min;\n    let 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        [min, max] = [max, min];\n    }\n    return { min, 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    let origin = 0.5;\n    const sourceLength = calcLength(source);\n    const 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    const 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}\nconst defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(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    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : dragElastic[label] || 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","const createAxisDelta = () => ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n});\nconst createDelta = () => ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n});\nconst createAxis = () => ({ min: 0, max: 0 });\nconst createBox = () => ({\n    x: createAxis(),\n    y: createAxis(),\n});\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\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({ top, left, right, bottom, }) {\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox({ x, 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    const topLeft = transformPoint({ x: point.left, y: point.top });\n    const 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","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale({ scale, scaleX, scaleY }) {\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        has2DTranslate(values) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction has2DTranslate(values) {\n    return is2DTranslate(values.x) || is2DTranslate(values.y);\n}\nfunction is2DTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { has2DTranslate, hasScale, hasTransform };\n","import { mix } from '../../utils/mix.mjs';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    const distanceFromOrigin = point - originPoint;\n    const scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, { x, y }) {\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {\n    var _a, _b;\n    const treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    let node;\n    let delta;\n    for (let i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, {\n                x: -node.scroll.offset.x,\n                y: -node.scroll.offset.y,\n            });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n    /**\n     * Snap tree scale back to 1 if it's within a non-perceivable threshold.\n     * This will help reduce useless scales getting rendered.\n     */\n    treeScale.x = snapToDefault(treeScale.x);\n    treeScale.y = snapToDefault(treeScale.y);\n}\nfunction snapToDefault(scale) {\n    if (Number.isInteger(scale))\n        return scale;\n    return scale > 1.0000000000001 || scale < 0.999999999999 ? scale : 1;\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, transforms, [key, scaleKey, originKey]) {\n    const axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    const originPoint = mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform, xKeys);\n    transformAxis(box.y, transform, yKeys);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\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    const viewportBox = measureViewportBox(element, transformPagePoint);\n    const { scroll } = rootProjectionNode;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.offset.x);\n        translateAxis(viewportBox.y, scroll.offset.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","const instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","function isWaapiSupportedEasing(easing) {\n    return (!easing || // Default easing\n        Array.isArray(easing) || // Bezier curve\n        (typeof easing === \"string\" && supportedWaapiEasing[easing]));\n}\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\nconst supportedWaapiEasing = {\n    linear: \"linear\",\n    ease: \"ease\",\n    easeIn: \"ease-in\",\n    easeOut: \"ease-out\",\n    easeInOut: \"ease-in-out\",\n    circIn: cubicBezierAsString([0, 0.65, 0.55, 1]),\n    circOut: cubicBezierAsString([0.55, 0, 1, 0.45]),\n    backIn: cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),\n    backOut: cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),\n};\nfunction mapEasingToNativeEasing(easing) {\n    if (!easing)\n        return undefined;\n    return Array.isArray(easing)\n        ? cubicBezierAsString(easing)\n        : supportedWaapiEasing[easing];\n}\n\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing };\n","import { sync } from '../../frameloop/index.mjs';\nimport { animate } from '../legacy-popmotion/index.mjs';\nimport { animateStyle } from './index.mjs';\nimport { isWaapiSupportedEasing } from './easing.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\nfunction createAcceleratedAnimation(value, valueName, { onUpdate, onComplete, ...options }) {\n    let { keyframes, duration = 0.3, elapsed = 0, ease } = options;\n    /**\n     * If this animation needs pre-generated keyframes then generate.\n     */\n    if (options.type === \"spring\" || !isWaapiSupportedEasing(options.ease)) {\n        const sampleAnimation = animate(options);\n        let state = { done: false, value: keyframes[0] };\n        const pregeneratedKeyframes = [];\n        let t = 0;\n        while (!state.done) {\n            state = sampleAnimation.sample(t);\n            pregeneratedKeyframes.push(state.value);\n            t += sampleDelta;\n        }\n        keyframes = pregeneratedKeyframes;\n        duration = t - sampleDelta;\n        ease = \"linear\";\n    }\n    const animation = animateStyle(value.owner.current, valueName, keyframes, {\n        ...options,\n        delay: -elapsed,\n        duration,\n        /**\n         * This function is currently not called if ease is provided\n         * as a function so the cast is safe.\n         *\n         * However it would be possible for a future refinement to port\n         * in easing pregeneration from Motion One for browsers that\n         * support the upcoming `linear()` easing function.\n         */\n        ease: ease,\n    });\n    /**\n     * Prefer the `onfinish` prop as it's more widely supported than\n     * the `finished` promise.\n     *\n     * Here, we synchronously set the provided MotionValue to the end\n     * keyframe. If we didn't, when the WAAPI animation is finished it would\n     * be removed from the element which would then revert to its old styles.\n     */\n    animation.onfinish = () => {\n        value.set(keyframes[keyframes.length - 1]);\n        onComplete && onComplete();\n    };\n    /**\n     * Animation interrupt callback.\n     */\n    return () => {\n        /**\n         * WAAPI doesn't natively have any interruption capabilities.\n         *\n         * Rather than read commited styles back out of the DOM, we can\n         * create a renderless JS animation and sample it twice to calculate\n         * its current value, \"previous\" value, and therefore allow\n         * Motion to calculate velocity for any subsequent animation.\n         */\n        const { currentTime } = animation;\n        if (currentTime) {\n            const sampleAnimation = animate(options);\n            value.setWithVelocity(sampleAnimation.sample(currentTime - sampleDelta).value, sampleAnimation.sample(currentTime).value, sampleDelta);\n        }\n        sync.update(() => animation.cancel());\n    };\n}\n\nexport { createAcceleratedAnimation };\n","import { mapEasingToNativeEasing } from './easing.mjs';\n\nfunction animateStyle(element, valueName, keyframes, { delay = 0, duration, repeat = 0, repeatType = \"loop\", ease, times, } = {}) {\n    return element.animate({ [valueName]: keyframes, offset: times }, {\n        delay,\n        duration,\n        easing: mapEasingToNativeEasing(ease),\n        fill: \"both\",\n        iterations: repeat + 1,\n        direction: repeatType === \"reverse\" ? \"alternate\" : \"normal\",\n    });\n}\n\nexport { animateStyle };\n","import { sync, cancelSync } from '../frameloop/index.mjs';\n\n/**\n * Timeout defined in ms\n */\nfunction delay(callback, timeout) {\n    const start = performance.now();\n    const checkElapsed = ({ timestamp }) => {\n        const elapsed = timestamp - start;\n        if (elapsed >= timeout) {\n            cancelSync.read(checkElapsed);\n            callback(elapsed - timeout);\n        }\n    };\n    sync.read(checkElapsed, true);\n    return () => cancelSync.read(checkElapsed);\n}\n\nexport { delay };\n","import { delay } from '../utils/delay.mjs';\n\nfunction createInstantAnimation({ keyframes, elapsed, onUpdate, onComplete, }) {\n    const setValue = () => {\n        onUpdate && onUpdate(keyframes[keyframes.length - 1]);\n        onComplete && onComplete();\n        return () => { };\n    };\n    return elapsed ? delay(setValue, -elapsed) : setValue();\n}\n\nexport { createInstantAnimation };\n","const underDampedSpring = () => ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n});\nconst criticallyDampedSpring = (target) => ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: target === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n});\nconst linearTween = () => ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n});\nconst keyframesTransition = {\n    type: \"keyframes\",\n    duration: 0.8,\n};\nconst defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nconst getDefaultTransition = (valueKey, { keyframes }) => {\n    if (keyframes.length > 2) {\n        return keyframesTransition;\n    }\n    else {\n        const factory = defaultTransitions[valueKey] || defaultTransitions.default;\n        return factory(keyframes[1]);\n    }\n};\n\nexport { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };\n","import { complex } from '../../value/types/complex/index.mjs';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (key, value) => {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        complex.test(value) && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true;\n    }\n    return false;\n};\n\nexport { isAnimatable };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n    ...numberValueTypes,\n    // Color props\n    color,\n    backgroundColor: color,\n    outlineColor: color,\n    fill: color,\n    stroke: color,\n    // Border props\n    borderColor: color,\n    borderTopColor: color,\n    borderRightColor: color,\n    borderBottomColor: color,\n    borderLeftColor: color,\n    filter,\n    WebkitFilter: filter,\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = (key) => defaultValueTypes[key];\n\nexport { defaultValueTypes, getDefaultValueType };\n","import { complex } from '../../../value/types/complex/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nexport { getAnimatableNone };\n","import { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\n\n/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, ...transition }) {\n    return !!Object.keys(transition).length;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n\nexport { getValueTransition, getZeroUnit, isTransitionDefined, isZero };\n","const featureTests = {\n    waapi: () => Object.hasOwnProperty.call(Element.prototype, \"animate\"),\n};\nconst results = {};\nconst supports = {};\n/**\n * Generate features tests that cache their results.\n */\nfor (const key in featureTests) {\n    supports[key] = () => {\n        if (results[key] === undefined)\n            results[key] = featureTests[key]();\n        return results[key];\n    };\n}\n\nexport { supports };\n","import { warning } from 'hey-listen';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { instantAnimationState } from '../utils/use-instant-transition-state.mjs';\nimport { createAcceleratedAnimation } from './waapi/create-accelerated-animation.mjs';\nimport { createInstantAnimation } from './create-instant-animation.mjs';\nimport { animate } from './legacy-popmotion/index.mjs';\nimport { inertia } from './legacy-popmotion/inertia.mjs';\nimport { getDefaultTransition } from './utils/default-transitions.mjs';\nimport { isAnimatable } from './utils/is-animatable.mjs';\nimport { getKeyframes } from './utils/keyframes.mjs';\nimport { getValueTransition, isTransitionDefined } from './utils/transitions.mjs';\nimport { supports } from './waapi/supports.mjs';\n\n/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\"opacity\"]);\nconst createMotionValueAnimation = (valueName, value, target, transition = {}) => {\n    return (onComplete) => {\n        const valueTransition = getValueTransition(transition, valueName) || {};\n        /**\n         * Most transition values are currently completely overwritten by value-specific\n         * transitions. In the future it'd be nicer to blend these transitions. But for now\n         * delay actually does inherit from the root transition if not value-specific.\n         */\n        const delay = valueTransition.delay || transition.delay || 0;\n        /**\n         * Elapsed isn't a public transition option but can be passed through from\n         * optimized appear effects in milliseconds.\n         */\n        let { elapsed = 0 } = transition;\n        elapsed = elapsed - secondsToMilliseconds(delay);\n        const keyframes = getKeyframes(value, valueName, target, valueTransition);\n        /**\n         * Check if we're able to animate between the start and end keyframes,\n         * and throw a warning if we're attempting to animate between one that's\n         * animatable and another that isn't.\n         */\n        const originKeyframe = keyframes[0];\n        const targetKeyframe = keyframes[keyframes.length - 1];\n        const isOriginAnimatable = isAnimatable(valueName, originKeyframe);\n        const isTargetAnimatable = isAnimatable(valueName, targetKeyframe);\n        warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${valueName} from \"${originKeyframe}\" to \"${targetKeyframe}\". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \\`style\\` property.`);\n        let options = {\n            keyframes,\n            velocity: value.getVelocity(),\n            ...valueTransition,\n            elapsed,\n            onUpdate: (v) => {\n                value.set(v);\n                valueTransition.onUpdate && valueTransition.onUpdate(v);\n            },\n            onComplete: () => {\n                onComplete();\n                valueTransition.onComplete && valueTransition.onComplete();\n            },\n        };\n        if (!isOriginAnimatable ||\n            !isTargetAnimatable ||\n            instantAnimationState.current ||\n            valueTransition.type === false) {\n            /**\n             * If we can't animate this value, or the global instant animation flag is set,\n             * or this is simply defined as an instant transition, return an instant transition.\n             */\n            return createInstantAnimation(options);\n        }\n        else if (valueTransition.type === \"inertia\") {\n            /**\n             * If this is an inertia animation, we currently don't support pre-generating\n             * keyframes for this as such it must always run on the main thread.\n             */\n            const animation = inertia(options);\n            return () => animation.stop();\n        }\n        /**\n         * If there's no transition defined for this value, we can generate\n         * unqiue transition settings for this value.\n         */\n        if (!isTransitionDefined(valueTransition)) {\n            options = {\n                ...options,\n                ...getDefaultTransition(valueName, options),\n            };\n        }\n        /**\n         * Both WAAPI and our internal animation functions use durations\n         * as defined by milliseconds, while our external API defines them\n         * as seconds.\n         */\n        if (options.duration) {\n            options.duration = secondsToMilliseconds(options.duration);\n        }\n        if (options.repeatDelay) {\n            options.repeatDelay = secondsToMilliseconds(options.repeatDelay);\n        }\n        const visualElement = value.owner;\n        const element = visualElement && visualElement.current;\n        const canAccelerateAnimation = supports.waapi() &&\n            acceleratedValues.has(valueName) &&\n            !options.repeatDelay &&\n            options.repeatType !== \"mirror\" &&\n            options.damping !== 0 &&\n            visualElement &&\n            element instanceof HTMLElement &&\n            !visualElement.getProps().onUpdate;\n        if (canAccelerateAnimation) {\n            /**\n             * If this animation is capable of being run via WAAPI, then do so.\n             */\n            return createAcceleratedAnimation(value, valueName, options);\n        }\n        else {\n            /**\n             * Otherwise, fall back to the main thread.\n             */\n            const animation = animate(options);\n            return () => animation.stop();\n        }\n    };\n};\n\nexport { createMotionValueAnimation };\n","import { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\nimport { isAnimatable } from './is-animatable.mjs';\nimport { isZero, getZeroUnit } from './transitions.mjs';\n\nfunction getKeyframes(value, valueName, target, transition) {\n    const isTargetAnimatable = isAnimatable(valueName, target);\n    let origin = transition.from !== undefined ? transition.from : value.get();\n    if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n        /**\n         * If we're trying to animate from \"none\", try and get an animatable version\n         * of the target. This could be improved to work both ways.\n         */\n        origin = getAnimatableNone(valueName, target);\n    }\n    else if (isZero(origin) && typeof target === \"string\") {\n        origin = getZeroUnit(target);\n    }\n    else if (!Array.isArray(target) &&\n        isZero(target) &&\n        typeof origin === \"string\") {\n        target = getZeroUnit(origin);\n    }\n    /**\n     * If the target has been defined as a series of keyframes\n     */\n    if (Array.isArray(target)) {\n        /**\n         * Ensure an initial wildcard keyframe is hydrated by the origin.\n         * TODO: Support extra wildcard keyframes i.e [1, null, 0]\n         */\n        if (target[0] === null) {\n            target[0] = origin;\n        }\n        return target;\n    }\n    else {\n        return [origin, target];\n    }\n}\n\nexport { getKeyframes };\n","import { animate } from './index.mjs';\nimport { velocityPerSecond } from '../../utils/velocity-per-second.mjs';\nimport { frameData } from '../../frameloop/data.mjs';\n\nfunction inertia({ keyframes, velocity = 0, min, max, power = 0.8, timeConstant = 750, bounceStiffness = 500, bounceDamping = 10, restDelta = 1, modifyTarget, driver, onUpdate, onComplete, onStop, }) {\n    const origin = keyframes[0];\n    let currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function findNearestBoundary(v) {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    }\n    function startAnimation(options) {\n        currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n        currentAnimation = animate({\n            keyframes: [0, 1],\n            velocity: 0,\n            ...options,\n            driver,\n            onUpdate: (v) => {\n                var _a;\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n                (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n            },\n            onComplete,\n            onStop,\n        });\n    }\n    function startSpring(options) {\n        startAnimation({\n            type: \"spring\",\n            stiffness: bounceStiffness,\n            damping: bounceDamping,\n            restDelta,\n            ...options,\n        });\n    }\n    if (isOutOfBounds(origin)) {\n        // Start the animation with spring if outside the defined boundaries\n        startSpring({\n            velocity,\n            keyframes: [origin, findNearestBoundary(origin)],\n        });\n    }\n    else {\n        /**\n         * Or if the value is out of bounds, simulate the inertia movement\n         * with the decay animation.\n         *\n         * Pre-calculate the target so we can detect if it's out-of-bounds.\n         * If it is, we want to check per frame when to switch to a spring\n         * animation\n         */\n        let target = power * velocity + origin;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        const boundary = findNearestBoundary(target);\n        const heading = boundary === min ? -1 : 1;\n        let prev;\n        let current;\n        const checkBoundary = (v) => {\n            prev = current;\n            current = v;\n            velocity = velocityPerSecond(v - prev, frameData.delta);\n            if ((heading === 1 && v > boundary) ||\n                (heading === -1 && v < boundary)) {\n                startSpring({ keyframes: [v, boundary], velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            keyframes: [origin, 0],\n            velocity,\n            timeConstant,\n            power,\n            restDelta,\n            modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: () => currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop(),\n    };\n}\n\nexport { inertia };\n","import { 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 { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\nimport { mix } from '../../utils/mix.mjs';\nimport { percent } from '../../value/types/numbers/units.mjs';\nimport { createMotionValueAnimation } from '../../animation/index.mjs';\n\nconst elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nclass VisualElementDragControls {\n    constructor(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    start(originEvent, { snapToCursor = false } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        const onSessionStart = (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        const onStart = (event, info) => {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\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((axis) => {\n                var _a, _b;\n                let 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                    const measuredAxis = (_b = (_a = this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.layoutBox[axis];\n                    if (measuredAxis) {\n                        const length = calcLength(measuredAxis);\n                        current = length * (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        const onMove = (event, info) => {\n            // latestPointerEvent = event\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openGlobalLock)\n                return;\n            const { offset } = info;\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.render();\n            /**\n             * This must fire after the render 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        const onSessionEnd = (event, info) => this.stop(event, info);\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    }\n    stop(event, info) {\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        const { velocity } = info;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    }\n    cancel() {\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        const { dragPropagation } = this.getProps();\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    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let 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    resolveConstraints() {\n        const { dragConstraints, dragElastic } = this.getProps();\n        const { layout } = this.visualElement.projection || {};\n        const 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.layoutBox, 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((axis) => {\n                if (this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        const 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        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, 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            const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (constraints === null || constraints === void 0 ? void 0 : constraints[axis]) || {};\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            const bounceStiffness = dragElastic ? 200 : 1000000;\n            const bounceDamping = dragElastic ? 40 : 10000000;\n            const inertia = {\n                type: \"inertia\",\n                velocity: dragMomentum ? velocity[axis] : 0,\n                bounceStiffness,\n                bounceDamping,\n                timeConstant: 750,\n                restDelta: 1,\n                restSpeed: 10,\n                ...dragTransition,\n                ...transition,\n            };\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    startAxisValueAnimation(axis, transition) {\n        const axisValue = this.getAxisMotionValue(axis);\n        return axisValue.start(createMotionValueAnimation(axis, axisValue, 0, transition));\n    }\n    stopAnimation() {\n        eachAxis((axis) => 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    getAxisMotionValue(axis) {\n        var _a;\n        const dragKey = \"_drag\" + axis.toUpperCase();\n        const externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, ((_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) || 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\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    scalePositionWithinConstraints() {\n        var _a;\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\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        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue) {\n                const 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        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.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((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    }\n    addListeners() {\n        var _a;\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            drag && dragListener && this.start(event);\n        });\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (isRefObject(dragConstraints)) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        };\n        const { projection } = this.visualElement;\n        const 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        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const 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.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener === null || stopLayoutUpdateListener === void 0 ? void 0 : stopLayoutUpdateListener();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\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 = 10) {\n    let 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","const makeRenderlessComponent = (hook) => (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\nconst 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 * @privateRemarks\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({ onPan, onPanStart, onPanEnd, onPanSessionStart, visualElement, }) {\n    const hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    const panSession = useRef(null);\n    const { transformPagePoint } = useContext(MotionConfigContext);\n    const handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: (event, info) => {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    useEffect(() => {\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,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(() => 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    const { dragControls: groupDragControls, visualElement } = props;\n    const dragControls = useConstant(() => 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(() => groupDragControls && groupDragControls.subscribe(dragControls), [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(() => dragControls.addListeners(), [dragControls]);\n}\n\nexport { useDrag };\n","import { useContext, useId, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.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    const context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    const { isPresent, onExitComplete, register } = context;\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    const id = useId();\n    useEffect(() => register(id), []);\n    const safeToRemove = () => onExitComplete && 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 '../../value/types/numbers/units.mjs';\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 */\nconst correctBorderRadius = {\n    correct: (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        const x = pixelsToPercent(latest, node.target.x);\n        const y = pixelsToPercent(latest, node.target.y);\n        return `${x}% ${y}%`;\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\n","import { 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 */\nconst cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    const match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token, fallback] = match;\n    return [token, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element, depth = 1) {\n    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n    const [token, fallback] = parseCSSVariable(current);\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    const 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, { ...target }, transitionEnd) {\n    const element = visualElement.current;\n    if (!(element instanceof Element))\n        return { target, 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 = { ...transitionEnd };\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.values.forEach((value) => {\n        const current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        const 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 (const key in target) {\n        const current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        const 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 && transitionEnd[key] === undefined) {\n            transitionEnd[key] = current;\n        }\n    }\n    return { target, transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","import { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\nimport { mix } from '../../utils/mix.mjs';\nimport { complex } from '../../value/types/complex/index.mjs';\n\nconst varToken = \"_$css\";\nconst correctBoxShadow = {\n    correct: (latest, { treeScale, projectionDelta }) => {\n        const original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        const containsCSSVariables = latest.includes(\"var(\");\n        const cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, (match) => {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        const shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        const template = complex.createTransformer(latest);\n        const offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        const xScale = projectionDelta.x.scale * treeScale.x;\n        const 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        const 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        let output = template(shadow);\n        if (containsCSSVariables) {\n            let i = 0;\n            output = output.replace(varToken, () => {\n                const cssVariable = cssVariables[i];\n                i++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nexport { correctBoxShadow };\n","import { sync } from '../../../frameloop/index.mjs';\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/state.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\nclass MeasureLayoutWithContext extends React__default.Component {\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    componentDidMount() {\n        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;\n        const { projection } = visualElement;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", () => {\n                this.safeToRemove();\n            });\n            projection.setOptions({\n                ...projection.options,\n                onExitComplete: () => this.safeToRemove(),\n            });\n        }\n        globalProjectionState.hasEverUpdated = true;\n    }\n    getSnapshotBeforeUpdate(prevProps) {\n        const { layoutDependency, visualElement, drag, isPresent } = this.props;\n        const 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(() => {\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    componentDidUpdate() {\n        const { projection } = this.props.visualElement;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    }\n    componentWillUnmount() {\n        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;\n        const { projection } = visualElement;\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    safeToRemove() {\n        const { safeToRemove } = this.props;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    }\n    render() {\n        return null;\n    }\n}\nfunction MeasureLayout(props) {\n    const [isPresent, safeToRemove] = usePresence();\n    const layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));\n}\nconst defaultScaleCorrectors = {\n    borderRadius: {\n        ...correctBorderRadius,\n        applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ],\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\nconst layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    const prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (let 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 */\nconst isNumericalString = (v) => /^\\-?\\d*\\.?\\d+$/.test(v);\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nconst isZeroValueString = (v) => /^0[^.\\s]+$/.test(v);\n\nexport { isZeroValueString };\n","/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px, percent, degrees, vw, vh } from '../../../value/types/numbers/units.mjs';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nconst auto = {\n    test: (v) => v === \"auto\",\n    parse: (v) => v,\n};\n\nexport { auto };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { complex } from '../../../value/types/complex/index.mjs';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = (v) => valueTypes.find(testValueType(v));\n\nexport { findValueType };\n","import { resolveVariantFromProps } from './resolve-variants.mjs';\n\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    const current = {};\n    visualElement.values.forEach((value, key) => (current[key] = value.get()));\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    const velocity = {};\n    visualElement.values.forEach((value, key) => (velocity[key] = value.getVelocity()));\n    return velocity;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\n\nexport { resolveVariant };\n","import { 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 { complex } from '../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './resolve-dynamic-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    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    const reversedLabels = [...variantLabels].reverse();\n    reversedLabels.forEach((key) => {\n        var _a;\n        const variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((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;\n    const newValueKeys = Object.keys(target).filter((key) => !visualElement.hasValue(key));\n    const numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (let i = 0; i < numNewValues; i++) {\n        const key = newValueKeys[i];\n        const targetValue = target[key];\n        let 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, { owner: visualElement }));\n        if (origin[key] === undefined) {\n            origin[key] = value;\n        }\n        if (value !== null)\n            visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    const valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a;\n    const origin = {};\n    for (const key in target) {\n        const transitionOrigin = getOriginFromTransition(key, transition);\n        origin[key] =\n            transitionOrigin !== undefined\n                ? transitionOrigin\n                : (_a = visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.get();\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n","const appearStoreId = (id, value) => `${id}: ${value}`;\n\nexport { appearStoreId };\n","import { sync } from '../../frameloop/index.mjs';\nimport { transformProps } from '../../render/html/utils/transform.mjs';\nimport { appearStoreId } from './store-id.mjs';\n\nfunction handoffOptimizedAppearAnimation(id, name) {\n    const { MotionAppearAnimations } = window;\n    const animationId = appearStoreId(id, transformProps.has(name) ? \"transform\" : name);\n    const animation = MotionAppearAnimations && MotionAppearAnimations.get(animationId);\n    if (animation) {\n        /**\n         * We allow the animation to persist until the next frame:\n         *   1. So it continues to play until Framer Motion is ready to render\n         *      (avoiding a potential flash of the element's original state)\n         *   2. As all independent transforms share a single transform animation, stopping\n         *      it synchronously would prevent subsequent transforms from handing off.\n         */\n        sync.render(() => {\n            /**\n             * Animation.cancel() throws so it needs to be wrapped in a try/catch\n             */\n            try {\n                animation.cancel();\n                MotionAppearAnimations.delete(animationId);\n            }\n            catch (e) { }\n        });\n        return animation.currentTime || 0;\n    }\n    else {\n        return 0;\n    }\n}\n\nexport { handoffOptimizedAppearAnimation };\n","import { camelToDash } from '../../render/dom/utils/camel-to-dash.mjs';\n\nconst optimizedAppearDataId = \"framerAppearId\";\nconst optimizedAppearDataAttribute = \"data-\" + camelToDash(optimizedAppearDataId);\n\nexport { optimizedAppearDataAttribute, optimizedAppearDataId };\n","import { setTarget } from './setters.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { transformProps } from '../html/utils/transform.mjs';\nimport { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { handoffOptimizedAppearAnimation } from '../../animation/optimized-appear/handoff.mjs';\nimport { optimizedAppearDataAttribute } from '../../animation/optimized-appear/data-id.mjs';\nimport { createMotionValueAnimation } from '../../animation/index.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(() => visualElement.notify(\"AnimationComplete\", definition));\n}\nfunction animateVariant(visualElement, variant, options = {}) {\n    var _a;\n    const resolved = resolveVariant(visualElement, variant, options.custom);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\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    const getAnimation = resolved\n        ? () => animateTarget(visualElement, resolved, options)\n        : () => 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    const getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => 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    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\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, { delay = 0, transitionOverride, type } = {}) {\n    var _a;\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = visualElement.makeTargetAnimatable(definition);\n    const willChange = visualElement.getValue(\"willChange\");\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type && ((_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.getState()[type]);\n    for (const key in target) {\n        const value = visualElement.getValue(key);\n        const valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        let valueTransition = { delay, elapsed: 0, ...transition };\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && transformProps.has(key)) {\n            valueTransition = {\n                ...valueTransition,\n                type: false,\n                delay: 0,\n            };\n        }\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        if (!value.hasAnimated) {\n            const appearId = visualElement.getProps()[optimizedAppearDataAttribute];\n            if (appearId) {\n                valueTransition.elapsed = handoffOptimizedAppearAnimation(appearId, key);\n            }\n        }\n        let animation = value.start(createMotionValueAnimation(key, value, valueTarget, valueTransition));\n        if (isWillChangeMotionValue(willChange)) {\n            willChange.add(key);\n            animation = animation.then(() => willChange.remove(key));\n        }\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(() => {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.values.forEach((value) => 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({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\n","import { 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 { isVariantLabel } from './is-variant-label.mjs';\nimport { AnimationType } from './types.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\nconst variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.InView,\n    AnimationType.Focus,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Exit,\n];\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let 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    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\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        const props = visualElement.getProps();\n        const 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        const 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        const 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        let 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        let removedVariantIndex = Infinity;\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 (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined ? props[type] : context[type];\n            const 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            const 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            let 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 = { ...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                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            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let 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            const 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            let 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            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const 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 = { ...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(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\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            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let 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((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        [AnimationType.Animate]: createTypeState(true),\n        [AnimationType.InView]: createTypeState(),\n        [AnimationType.Hover]: createTypeState(),\n        [AnimationType.Tap]: createTypeState(),\n        [AnimationType.Drag]: createTypeState(),\n        [AnimationType.Focus]: createTypeState(),\n        [AnimationType.Exit]: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState, variantPriorityOrder };\n","import { 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\nconst animations = {\n    animation: makeRenderlessComponent(({ visualElement, 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(() => animate.subscribe(visualElement), [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent((props) => {\n        const { custom, visualElement } = props;\n        const [isPresent, safeToRemove] = usePresence();\n        const presenceContext = useContext(PresenceContext);\n        useEffect(() => {\n            visualElement.isPresent = isPresent;\n            const animation = visualElement.animationState &&\n                visualElement.animationState.setActive(AnimationType.Exit, !isPresent, {\n                    custom: (presenceContext && presenceContext.custom) ||\n                        custom,\n                });\n            if (animation && !isPresent) {\n                animation.then(safeToRemove);\n            }\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 (event, info) => {\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        if (visualElement.animationState) {\n            visualElement.animationState.setActive(AnimationType.Hover, isActive);\n        }\n        callback && callback(event, info);\n    };\n}\nfunction useHoverGesture({ onHoverStart, onHoverEnd, whileHover, visualElement, }) {\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\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 */\nconst isNodeOrChild = (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","/**\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 */\nconst 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 */\nconst observers = new WeakMap();\nconst fireObserverCallback = (entry) => {\n    const callback = observerCallbacks.get(entry.target);\n    callback && callback(entry);\n};\nconst fireAllObserverCallbacks = (entries) => {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver({ root, ...options }) {\n    const 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    const rootObservers = observers.get(lookupRoot);\n    const 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, { root, ...options });\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    const rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return () => {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { env } 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({ visualElement, whileInView, onViewportEnter, onViewportLeave, viewport = {}, }) {\n    const state = useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    let shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    const useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, { root, margin: rootMargin, amount = \"some\", once }) {\n    useEffect(() => {\n        if (!shouldObserve || !visualElement.current)\n            return;\n        const options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const intersectionCallback = (entry) => {\n            const { isIntersecting } = entry;\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            if (visualElement.animationState) {\n                visualElement.animationState.setActive(AnimationType.InView, isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const props = visualElement.getProps();\n            const callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(visualElement.current, 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, { fallback = true }) {\n    useEffect(() => {\n        if (!shouldObserve || !fallback)\n            return;\n        if (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(() => {\n            state.hasEnteredView = true;\n            const { onViewportEnter } = visualElement.getProps();\n            onViewportEnter && onViewportEnter(null);\n            if (visualElement.animationState) {\n                visualElement.animationState.setActive(AnimationType.InView, true);\n            }\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\nconst 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 { AnimationType } from '../render/utils/types.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { pipe } from '../utils/pipe.mjs';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture({ onTap, onTapStart, onTapCancel, whileTap, visualElement, }) {\n    const hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    const isPressing = useRef(false);\n    const cancelPointerEndListeners = useRef(null);\n    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    const eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        cancelPointerEndListeners.current && cancelPointerEndListeners.current();\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        removePointerEndListener();\n        isPressing.current = false;\n        visualElement.animationState &&\n            visualElement.animationState.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.current, event.target)\n            ? onTapCancel && onTapCancel(event, info)\n            : onTap && onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel && onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        visualElement.animationState &&\n            visualElement.animationState.setActive(AnimationType.Tap, true);\n        onTapStart && onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\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({ whileFocus, visualElement, }) {\n    const { animationState } = visualElement;\n    const onFocus = () => {\n        animationState && animationState.setActive(AnimationType.Focus, true);\n    };\n    const onBlur = () => {\n        animationState && animationState.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 { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from 'hey-listen';\nimport { transformPropOrder } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\nimport { isBrowser } from '../../../utils/is-browser.mjs';\nimport { number } from '../../../value/types/numbers/index.mjs';\nimport { px } from '../../../value/types/numbers/units.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nconst isPositionalKey = (key) => positionalKeys.has(key);\nconst hasPositionalKey = (target) => {\n    return Object.keys(target).some(isPositionalKey);\n};\nconst setAndResetVelocity = (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};\nconst isNumOrPxType = (v) => v === number || v === px;\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 = {}));\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n    const removedTransforms = [];\n    nonTranslationalTransformKeys.forEach((key) => {\n        const 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.render();\n    return removedTransforms;\n}\nconst positionalValues = {\n    // Dimensions\n    width: ({ x }, { paddingLeft = \"0\", paddingRight = \"0\" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),\n    height: ({ y }, { paddingTop = \"0\", paddingBottom = \"0\" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),\n    top: (_bbox, { top }) => parseFloat(top),\n    left: (_bbox, { left }) => parseFloat(left),\n    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),\n    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nconst convertChangedValueTypes = (target, visualElement, changedKeys) => {\n    const originBbox = visualElement.measureViewportBox();\n    const element = visualElement.current;\n    const elementComputedStyle = getComputedStyle(element);\n    const { display } = elementComputedStyle;\n    const 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((key) => {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.render();\n    const targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach((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        const value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nconst checkAndConvertChangedValueTypes = (visualElement, target, origin = {}, transitionEnd = {}) => {\n    target = { ...target };\n    transitionEnd = { ...transitionEnd };\n    const 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    let removedTransformValues = [];\n    let hasAttemptedToRemoveTransformValues = false;\n    const changedValueTypeKeys = [];\n    targetPositionalKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        let from = origin[key];\n        let fromType = findDimensionValueType(from);\n        const to = target[key];\n        let 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            const numKeyframes = to.length;\n            const fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (let 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                const 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        const scrollY = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        const convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(([key, value]) => {\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.render();\n        // Restore scroll position\n        if (isBrowser && scrollY !== null) {\n            window.scrollTo({ top: scrollY });\n        }\n        return { target: convertedTarget, transitionEnd };\n    }\n    else {\n        return { target, 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, transitionEnd };\n}\n\nexport { BoundingBoxDimension, positionalValues, unitConversion };\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 */\nconst parseDomVariant = (visualElement, target, origin, transitionEnd) => {\n    const 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","// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n","import { sync, cancelSync } from '../frameloop/index.mjs';\nimport { invariant } from 'hey-listen';\nimport { createElement } from 'react';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isRefObject } from '../utils/is-ref-object.mjs';\nimport { env } from '../utils/process.mjs';\nimport { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isWillChangeMotionValue } from '../value/use-will-change/is.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { transformProps } from './html/utils/transform.mjs';\nimport { variantPriorityOrder } from './utils/animation-state.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { isVariantLabel } from './utils/is-variant-label.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\n\nconst featureNames = Object.keys(featureDefinitions);\nconst numFeatures = featureNames.length;\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"Unmount\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n    constructor({ parent, props, reducedMotionConfig, visualState, }, options = {}) {\n        /**\n         * A reference to the current underlying Instance, e.g. a HTMLElement\n         * or Three.Mesh etc.\n         */\n        this.current = null;\n        /**\n         * A set containing references to this VisualElement's children.\n         */\n        this.children = new Set();\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        this.isVariantNode = false;\n        this.isControllingVariants = false;\n        /**\n         * Decides whether this VisualElement should animate in reduced motion\n         * mode.\n         *\n         * TODO: This is currently set on every individual VisualElement but feels\n         * like it could be set globally.\n         */\n        this.shouldReduceMotion = null;\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        this.values = new Map();\n        /**\n         * Tracks whether this VisualElement's React component is currently present\n         * within the defined React tree.\n         */\n        this.isPresent = true;\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.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        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.scheduleRender = () => sync.render(this.render, false, true);\n        const { latestValues, renderState } = visualState;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.isControllingVariants = isControllingVariants(props);\n        this.isVariantNode = isVariantNode(props);\n        if (this.isVariantNode) {\n            this.variantChildren = new Set();\n        }\n        this.manuallyAnimateOnMount = Boolean(parent && parent.current);\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        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props);\n        for (const key in initialMotionValues) {\n            const value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n                if (isWillChangeMotionValue(willChange)) {\n                    willChange.add(key);\n                }\n            }\n        }\n    }\n    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props) {\n        return {};\n    }\n    mount(instance) {\n        var _a;\n        this.current = instance;\n        if (this.projection) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (this.parent)\n            this.parent.children.add(this);\n        this.setProps(this.props);\n    }\n    unmount() {\n        var _a, _b, _c;\n        (_a = this.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n        cancelSync.update(this.notifyUpdate);\n        cancelSync.render(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        (_b = this.removeFromVariantTree) === null || _b === void 0 ? void 0 : _b.call(this);\n        (_c = this.parent) === null || _c === void 0 ? void 0 : _c.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        const valueIsTransform = transformProps.has(key);\n        const removeOnChange = value.on(\"change\", (latestValue) => {\n            this.latestValues[key] = latestValue;\n            this.props.onUpdate &&\n                sync.update(this.notifyUpdate, false, true);\n            if (valueIsTransform && this.projection) {\n                this.projection.isTransformDirty = true;\n            }\n        });\n        const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type)\n            return 0;\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    loadFeatures(renderedProps, isStrict, preloadedFeatures, projectionId, ProjectionNodeConstructor, initialLayoutGroupConfig) {\n        const features = [];\n        /**\n         * If we're in development mode, check to make sure we're not rendering a motion component\n         * as a child of LazyMotion, as this will break the file-size benefits of using it.\n         */\n        if (env !== \"production\" && preloadedFeatures && isStrict) {\n            invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n        }\n        for (let i = 0; i < numFeatures; i++) {\n            const name = featureNames[i];\n            const { isEnabled, Component } = featureDefinitions[name];\n            /**\n             * It might be possible in the future to use this moment to\n             * dynamically request functionality. In initial tests this\n             * was producing a lot of duplication amongst bundles.\n             */\n            if (isEnabled(renderedProps) && Component) {\n                features.push(createElement(Component, {\n                    key: name,\n                    ...renderedProps,\n                    visualElement: this,\n                }));\n            }\n        }\n        if (!this.projection && ProjectionNodeConstructor) {\n            this.projection = new ProjectionNodeConstructor(projectionId, this.latestValues, this.parent && this.parent.projection);\n            const { layoutId, layout, drag, dragConstraints, layoutScroll } = renderedProps;\n            this.projection.setOptions({\n                layoutId,\n                layout,\n                alwaysMeasureLayout: Boolean(drag) ||\n                    (dragConstraints && isRefObject(dragConstraints)),\n                visualElement: this,\n                scheduleRender: () => this.scheduleRender(),\n                /**\n                 * TODO: Update options in an effect. This could be tricky as it'll be too late\n                 * to update by the time layout animations run.\n                 * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n                 * ensuring it gets called if there's no potential layout animations.\n                 *\n                 */\n                animationType: typeof layout === \"string\" ? layout : \"both\",\n                initialPromotionConfig: initialLayoutGroupConfig,\n                layoutScroll,\n            });\n        }\n        return features;\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, this.options, this.props);\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() {\n        return this.current\n            ? this.measureInstanceViewportBox(this.current, this.props)\n            : createBox();\n    }\n    getStaticValue(key) {\n        return this.latestValues[key];\n    }\n    setStaticValue(key, value) {\n        this.latestValues[key] = value;\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(target, canMutate = true) {\n        return this.makeTargetAnimatableFromInstance(target, this.props, canMutate);\n    }\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(props) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.props = props;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listener = props[\"on\" + key];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props), this.prevMotionValues);\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        var _a;\n        return (_a = this.props.variants) === null || _a === void 0 ? void 0 : _a[name];\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        var _a;\n        return this.isVariantNode ? this : (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getClosestVariantNode();\n    }\n    getVariantContext(startAtParent = false) {\n        var _a, _b;\n        if (startAtParent)\n            return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getVariantContext();\n        if (!this.isControllingVariants) {\n            const context = ((_b = this.parent) === null || _b === void 0 ? void 0 : _b.getVariantContext()) || {};\n            if (this.props.initial !== undefined) {\n                context.initial = this.props.initial;\n            }\n            return context;\n        }\n        const context = {};\n        for (let i = 0; i < numVariantProps; i++) {\n            const name = variantProps[i];\n            const prop = this.props[name];\n            if (isVariantLabel(prop) || prop === false) {\n                context[name] = prop;\n            }\n        }\n        return context;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        var _a;\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        if (this.hasValue(key))\n            this.removeValue(key);\n        this.values.set(key, value);\n        this.latestValues[key] = value.get();\n        this.bindToMotionValue(key, value);\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        var _a;\n        this.values.delete(key);\n        (_a = this.valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n        this.valueSubscriptions.delete(key);\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\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(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue, { owner: this });\n            this.addValue(key, value);\n        }\n        return value;\n    }\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(key) {\n        return this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : this.readValueFromInstance(this.current, key, this.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(key, value) {\n        this.baseTarget[key] = value;\n    }\n    /**\n     * Find the base target for a value thats been removed from all animation\n     * props.\n     */\n    getBaseTarget(key) {\n        var _a;\n        const { initial } = this.props;\n        const valueFromInitial = typeof initial === \"string\" || typeof initial === \"object\"\n            ? (_a = resolveVariantFromProps(this.props, initial)) === null || _a === void 0 ? void 0 : _a[key]\n            : undefined;\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        var _a;\n        (_a = this.events[eventName]) === null || _a === void 0 ? void 0 : _a.notify(...args);\n    }\n}\nconst variantProps = [\"initial\", ...variantPriorityOrder];\nconst numVariantProps = variantProps.length;\n\nexport { VisualElement };\n","import { isBrowser } from '../is-browser.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from './state.mjs';\n\nfunction initPrefersReducedMotion() {\n    hasReducedMotionListener.current = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);\n        motionMediaQuery.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n\nexport { initPrefersReducedMotion };\n","import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const 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            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"7.10.3\", `Attempting to mix Framer Motion versions ${nextValue.version} with 7.10.3 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\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                const 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                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { parseDomVariant } from './utils/parse-dom-variant.mjs';\nimport { VisualElement } from '../VisualElement.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    sortInstanceNodePosition(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    getBaseTargetFromProps(props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n    makeTargetAnimatableFromInstance({ transition, transitionEnd, ...target }, { transformValues }, isMounted) {\n        let origin = getOrigin(target, transition || {}, this);\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(this, target, origin);\n            const parsed = parseDomVariant(this, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return {\n            transition,\n            transitionEnd,\n            ...target,\n        };\n    }\n}\n\nexport { DOMVisualElement };\n","import { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { transformProps } 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';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, options, props) {\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props) {\n        return scrapeMotionValuesFromProps(props);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderHTML(instance, renderState, styleProp, projection);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.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 { transformProps } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.isSVGTag = false;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        var _a;\n        if (transformProps.has(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 instance.getAttribute(key);\n    }\n    measureInstanceViewportBox() {\n        return createBox();\n    }\n    scrapeMotionValuesFromProps(props) {\n        return scrapeMotionValuesFromProps(props);\n    }\n    build(renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, this.isSVGTag, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n    mount(instance) {\n        this.isSVGTag = isSVGTag(instance.tagName);\n        super.mount(instance);\n    }\n}\n\nexport { SVGVisualElement };\n","import { HTMLVisualElement } from '../html/HTMLVisualElement.mjs';\nimport { SVGVisualElement } from '../svg/SVGVisualElement.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nconst createDomVisualElement = (Component, options) => {\n    return isSVGComponent(Component)\n        ? new SVGVisualElement(options, { enableHardwareAcceleration: false })\n        : new HTMLVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { 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 */\nconst domAnimation = {\n    renderer: createDomVisualElement,\n    ...animations,\n    ...gestureAnimations,\n};\n\nexport { domAnimation };\n","import { circOut } from '../../easing/circ.mjs';\nimport { progress } from '../../utils/progress.mjs';\nimport { mix } from '../../utils/mix.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { percent, px } from '../../value/types/numbers/units.mjs';\n\nconst borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nconst numBorders = borders.length;\nconst asNumber = (value) => typeof value === \"string\" ? parseFloat(value) : value;\nconst isPx = (value) => typeof value === \"number\" || px.test(value);\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mix(0, \n        // TODO Reinstate this if only child\n        lead.opacity !== undefined ? lead.opacity : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mix(follow.opacity !== undefined ? follow.opacity : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mix(follow.opacity !== undefined ? follow.opacity : 1, lead.opacity !== undefined ? lead.opacity : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (let i = 0; i < numBorders; i++) {\n        const borderLabel = `border${borders[i]}Radius`;\n        let followRadius = getRadius(follow, borderLabel);\n        let leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        const canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (percent.test(leadRadius) || percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    return values[radiusName] !== undefined\n        ? values[radiusName]\n        : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nconst easeCrossfadeIn = compress(0, 0.5, circOut);\nconst easeCrossfadeOut = compress(0.5, 0.95, noop);\nfunction compress(min, max, easing) {\n    return (p) => {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(progress(min, max, p));\n    };\n}\n\nexport { mixValues };\n","/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n\nexport { copyAxisInto, copyBoxInto };\n","import { mix } from '../../utils/mix.mjs';\nimport { percent } from '../../value/types/numbers/units.mjs';\nimport { scalePoint } from './delta-apply.mjs';\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        const relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    let originPoint = mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","import { calcLength } from './delta-calc.mjs';\n\nfunction isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\nfunction aspectRatio(box) {\n    return calcLength(box.x) / calcLength(box.y);\n}\n\nexport { aspectRatio, boxEquals, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nclass NodeStack {\n    constructor() {\n        this.members = [];\n    }\n    add(node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    }\n    remove(node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            const prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    }\n    relegate(node) {\n        const indexOfNode = this.members.findIndex((member) => node === member);\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        let prevLead;\n        for (let i = indexOfNode; i >= 0; i--) {\n            const member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    promote(node, preserveFollowOpacity) {\n        var _a;\n        const prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            const { crossfade } = node.options;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    }\n    exitAnimationComplete() {\n        this.members.forEach((node) => {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    }\n    scheduleRender() {\n        this.members.forEach((node) => {\n            node.instance && node.scheduleRender(false);\n        });\n    }\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    removeLeadSnapshot() {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    }\n}\n\nexport { NodeStack };\n","function buildProjectionTransform(delta, treeScale, latestTransform) {\n    let transform = \"\";\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    const xTranslate = delta.x.translate / treeScale.x;\n    const yTranslate = delta.y.translate / treeScale.y;\n    if (xTranslate || yTranslate) {\n        transform = `translate3d(${xTranslate}px, ${yTranslate}px, 0) `;\n    }\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    if (treeScale.x !== 1 || treeScale.y !== 1) {\n        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;\n    }\n    if (latestTransform) {\n        const { rotate, rotateX, rotateY } = latestTransform;\n        if (rotate)\n            transform += `rotate(${rotate}deg) `;\n        if (rotateX)\n            transform += `rotateX(${rotateX}deg) `;\n        if (rotateY)\n            transform += `rotateY(${rotateY}deg) `;\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    const elementScaleX = delta.x.scale * treeScale.x;\n    const elementScaleY = delta.y.scale * treeScale.y;\n    if (elementScaleX !== 1 || elementScaleY !== 1) {\n        transform += `scale(${elementScaleX}, ${elementScaleY})`;\n    }\n    return transform || \"none\";\n}\n\nexport { buildProjectionTransform };\n","const compareByDepth = (a, b) => a.depth - b.depth;\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nclass FlatTree {\n    constructor() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    add(child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    }\n    remove(child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    }\n    forEach(callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    }\n}\n\nexport { FlatTree };\n","import { cancelSync, flushSync, sync } from '../../frameloop/index.mjs';\nimport { animate } from '../../animation/animate.mjs';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\nimport { mixValues } from '../animation/mix-values.mjs';\nimport { copyBoxInto } from '../geometry/copy.mjs';\nimport { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from '../geometry/delta-apply.mjs';\nimport { calcRelativePosition, calcRelativeBox, calcBoxDelta, calcLength, isNear } from '../geometry/delta-calc.mjs';\nimport { removeBoxTransforms } from '../geometry/delta-remove.mjs';\nimport { createBox, createDelta } from '../geometry/models.mjs';\nimport { getValueTransition } from '../../animation/utils/transitions.mjs';\nimport { boxEquals, isDeltaZero, aspectRatio } from '../geometry/utils.mjs';\nimport { NodeStack } from '../shared/stack.mjs';\nimport { scaleCorrectors } from '../styles/scale-correction.mjs';\nimport { buildProjectionTransform } from '../styles/transform.mjs';\nimport { eachAxis } from '../utils/each-axis.mjs';\nimport { hasTransform, hasScale, has2DTranslate } from '../utils/has-transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { globalProjectionState } from './state.mjs';\nimport { delay } from '../../utils/delay.mjs';\nimport { mix } from '../../utils/mix.mjs';\n\nconst transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nconst animationTarget = 1000;\nlet id = 0;\nfunction createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform, }) {\n    return class ProjectionNode {\n        constructor(elementId, latestValues = {}, parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent()) {\n            /**\n             * A unique ID generated for every projection node.\n             */\n            this.id = id++;\n            /**\n             * An id that represents a unique session instigated by startUpdate.\n             */\n            this.animationId = 0;\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            this.isTransformDirty = false;\n            /**\n             * Flag to true if we think the projection calculations for this or any\n             * child might need recalculating as a result of an updated transform or layout animation.\n             */\n            this.isProjectionDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to layoutly\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = () => {\n                if (this.isUpdating) {\n                    this.isUpdating = false;\n                    this.clearAllSnapshots();\n                }\n            };\n            /**\n             * This is a multi-step process as shared nodes might be of different depths. Nodes\n             * are sorted by depth order, so we need to resolve the entire tree before moving to\n             * the next step.\n             */\n            this.updateProjection = () => {\n                this.nodes.forEach(propagateDirtyNodes);\n                this.nodes.forEach(resolveTargetDelta);\n                this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.elementId = elementId;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? [...parent.path, parent] : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            elementId && this.root.registerPotentialNode(elementId, this);\n            for (let i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        addEventListener(name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        }\n        notifyListeners(name, ...args) {\n            const subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify(...args);\n        }\n        hasListeners(name) {\n            return this.eventHandlers.has(name);\n        }\n        registerPotentialNode(elementId, node) {\n            this.potentialNodes.set(elementId, node);\n        }\n        /**\n         * Lifecycles\n         */\n        mount(instance, isLayoutDirty = false) {\n            var _a;\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            const { layoutId, layout, visualElement } = this.options;\n            if (visualElement && !visualElement.current) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.elementId && this.root.potentialNodes.delete(this.elementId);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                let cancelDelay;\n                const resizeUnblockUpdate = () => (this.root.updateBlockedByResize = false);\n                attachResizeListener(instance, () => {\n                    this.root.updateBlockedByResize = true;\n                    cancelDelay && cancelDelay();\n                    cancelDelay = delay(resizeUnblockUpdate, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", ({ delta, hasLayoutChanged, hasRelativeTargetChanged, layout: newLayout, }) => {\n                    var _a, _b, _c, _d, _e;\n                    if (this.isTreeAnimationBlocked()) {\n                        this.target = undefined;\n                        this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    const layoutTransition = (_b = (_a = this.options.transition) !== null && _a !== void 0 ? _a : visualElement.getDefaultTransition()) !== null && _b !== void 0 ? _b : defaultLayoutTransition;\n                    const { onLayoutAnimationStart, onLayoutAnimationComplete, } = visualElement.getProps();\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    const targetChanged = !this.targetLayout ||\n                        !boxEquals(this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_c = this.resumeFrom) === null || _c === void 0 ? void 0 : _c.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !this.currentAnimation))) {\n                        if (this.resumeFrom) {\n                            this.resumingFrom = this.resumeFrom;\n                            this.resumingFrom.resumingFrom = undefined;\n                        }\n                        this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        const animationOptions = {\n                            ...getValueTransition(layoutTransition, \"layout\"),\n                            onPlay: onLayoutAnimationStart,\n                            onComplete: onLayoutAnimationComplete,\n                        };\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            this.animationProgress === 0) {\n                            finishAnimation(this);\n                        }\n                        this.isLead() && ((_e = (_d = this.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d));\n                    }\n                    this.targetLayout = newLayout;\n                });\n            }\n        }\n        unmount() {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            cancelSync.preRender(this.updateProjection);\n        }\n        // only on the root\n        blockUpdate() {\n            this.updateManuallyBlocked = true;\n        }\n        unblockUpdate() {\n            this.updateManuallyBlocked = false;\n        }\n        isUpdateBlocked() {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        }\n        isTreeAnimationBlocked() {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        }\n        // Note: currently only running on root node\n        startUpdate() {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n            this.animationId++;\n        }\n        willUpdate(shouldNotifyListeners = true) {\n            var _a, _b, _c;\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                node.shouldResetTransform = true;\n                node.updateScroll(\"snapshot\");\n            }\n            const { layoutId, layout } = this.options;\n            if (layoutId === undefined && !layout)\n                return;\n            const transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        }\n        // Note: Currently only running on root node\n        didUpdate() {\n            const updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            flushSync.update();\n            flushSync.preRender();\n            flushSync.render();\n        }\n        clearAllSnapshots() {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        }\n        scheduleUpdateProjection() {\n            sync.preRender(this.updateProjection, false, true);\n        }\n        scheduleCheckAfterUnmount() {\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync.postRender(() => {\n                if (this.isLayoutDirty) {\n                    this.root.didUpdate();\n                }\n                else {\n                    this.root.checkUpdateFailed();\n                }\n            });\n        }\n        /**\n         * Update measurements\n         */\n        updateSnapshot() {\n            if (this.snapshot || !this.instance)\n                return;\n            this.snapshot = this.measure();\n        }\n        updateLayout() {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (let i = 0; i < this.path.length; i++) {\n                    const node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            const prevLayout = this.layout;\n            this.layout = this.measure(false);\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.layoutBox);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notify(\"LayoutMeasure\", this.layout.layoutBox, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.layoutBox);\n        }\n        updateScroll(phase = \"measure\") {\n            let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);\n            if (this.scroll &&\n                this.scroll.animationId === this.root.animationId &&\n                this.scroll.phase === phase) {\n                needsMeasurement = false;\n            }\n            if (needsMeasurement) {\n                this.scroll = {\n                    animationId: this.root.animationId,\n                    phase,\n                    isRoot: checkIsScrollRoot(this.instance),\n                    offset: measureScroll(this.instance),\n                };\n            }\n        }\n        resetTransform() {\n            var _a;\n            if (!resetTransform)\n                return;\n            const isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            const transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            const transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        }\n        measure(removeTransform = true) {\n            const pageBox = this.measurePageBox();\n            let layoutBox = this.removeElementScroll(pageBox);\n            /**\n             * Measurements taken during the pre-render stage\n             * still have transforms applied so we remove them\n             * via calculation.\n             */\n            if (removeTransform) {\n                layoutBox = this.removeTransform(layoutBox);\n            }\n            roundBox(layoutBox);\n            return {\n                animationId: this.root.animationId,\n                measuredBox: pageBox,\n                layoutBox,\n                latestValues: {},\n                source: this.id,\n            };\n        }\n        measurePageBox() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return createBox();\n            const box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            const { scroll } = this.root;\n            if (scroll) {\n                translateAxis(box.x, scroll.offset.x);\n                translateAxis(box.y, scroll.offset.y);\n            }\n            return box;\n        }\n        removeElementScroll(box) {\n            const boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                const { scroll, options } = node;\n                if (node !== this.root && scroll && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (scroll.isRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        const { scroll: rootScroll } = this.root;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.offset.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.offset.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll.offset.x);\n                    translateAxis(boxWithoutScroll.y, scroll.offset.y);\n                }\n            }\n            return boxWithoutScroll;\n        }\n        applyTransform(box, transformOnly = false) {\n            const withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.offset.x,\n                        y: -node.scroll.offset.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        }\n        removeTransform(box) {\n            var _a;\n            const boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                const sourceBox = createBox();\n                const nodeBox = node.measurePageBox();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layoutBox, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        }\n        /**\n         *\n         */\n        setTargetDelta(delta) {\n            this.targetDelta = delta;\n            this.isProjectionDirty = true;\n            this.root.scheduleUpdateProjection();\n        }\n        setOptions(options) {\n            this.options = {\n                ...this.options,\n                ...options,\n                crossfade: options.crossfade !== undefined ? options.crossfade : true,\n            };\n        }\n        clearMeasurements() {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        }\n        /**\n         * Frame calculations\n         */\n        resolveTargetDelta() {\n            var _a;\n            /**\n             * Once the dirty status of nodes has been spread through the tree, we also\n             * need to check if we have a shared node of a different depth that has itself\n             * been dirtied.\n             */\n            const lead = this.getLead();\n            this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);\n            this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);\n            /**\n             * We don't use transform for this step of processing so we don't\n             * need to check whether any nodes have changed transform.\n             */\n            if (!this.isProjectionDirty && !this.attemptToResolveRelativeTarget)\n                return;\n            const { layout, layoutId } = this.options;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent && relativeParent.layout) {\n                    this.relativeParent = relativeParent;\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.layoutBox, relativeParent.layout.layoutBox);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.layoutBox);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.layoutBox);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.layoutBox);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent &&\n                    Boolean(relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !relativeParent.options.layoutScroll &&\n                    relativeParent.target) {\n                    this.relativeParent = relativeParent;\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n        }\n        getClosestProjectingParent() {\n            if (!this.parent ||\n                hasScale(this.parent.latestValues) ||\n                has2DTranslate(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        }\n        calcProjection() {\n            var _a;\n            const { isProjectionDirty, isTransformDirty } = this;\n            this.isProjectionDirty = this.isTransformDirty = false;\n            const lead = this.getLead();\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            let canSkip = true;\n            if (isProjectionDirty)\n                canSkip = false;\n            if (isShared && isTransformDirty)\n                canSkip = false;\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.layoutBox);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);\n            const { target } = lead;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            const prevTreeScaleX = this.treeScale.x;\n            const prevTreeScaleY = this.treeScale.y;\n            const prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        }\n        hide() {\n            this.isVisible = false;\n            // TODO: Schedule render\n        }\n        show() {\n            this.isVisible = true;\n            // TODO: Schedule render\n        }\n        scheduleRender(notifyAll = true) {\n            var _a, _b, _c;\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        }\n        setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {\n            var _a, _b;\n            const snapshot = this.snapshot;\n            const snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            const mixedValues = { ...this.latestValues };\n            const targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            const relativeLayout = createBox();\n            const isSharedLayoutAnimation = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.source) !== ((_a = this.layout) === null || _a === void 0 ? void 0 : _a.source);\n            const isOnlyMember = (((_b = this.getStack()) === null || _b === void 0 ? void 0 : _b.members.length) || 0) <= 1;\n            const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = (latest) => {\n                var _a;\n                const progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                this.setTargetDelta(targetDelta);\n                if (this.relativeTarget &&\n                    this.relativeTargetOrigin &&\n                    this.layout &&\n                    ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);\n                    mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                this.root.scheduleUpdateProjection();\n                this.scheduleRender();\n                this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        }\n        startAnimation(options) {\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync.update(() => {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                this.currentAnimation = animate(0, animationTarget, {\n                    ...options,\n                    onUpdate: (latest) => {\n                        var _a;\n                        this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    },\n                    onComplete: () => {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        this.completeAnimation();\n                    },\n                });\n                if (this.resumingFrom) {\n                    this.resumingFrom.currentAnimation = this.currentAnimation;\n                }\n                this.pendingAnimation = undefined;\n            });\n        }\n        completeAnimation() {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        }\n        finishAnimation() {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        }\n        applyTransformsToTarget() {\n            const lead = this.getLead();\n            let { targetWithTransforms, target, layout, latestValues } = lead;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            /**\n             * If we're only animating position, and this element isn't the lead element,\n             * then instead of projecting into the lead box we instead want to calculate\n             * a new target that aligns the two boxes but maintains the layout shape.\n             */\n            if (this !== lead &&\n                this.layout &&\n                layout &&\n                shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout.layoutBox)) {\n                target = this.target || createBox();\n                const xLength = calcLength(this.layout.layoutBox.x);\n                target.x.min = lead.target.x.min;\n                target.x.max = target.x.min + xLength;\n                const yLength = calcLength(this.layout.layoutBox.y);\n                target.y.min = lead.target.y.min;\n                target.y.max = target.y.min + yLength;\n            }\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its layout layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        }\n        registerSharedNode(layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            const stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        }\n        isLead() {\n            const stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        }\n        getLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        }\n        getPrevLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        }\n        getStack() {\n            const { layoutId } = this.options;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        }\n        promote({ needsReset, transition, preserveFollowOpacity, } = {}) {\n            const stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition });\n        }\n        relegate() {\n            const stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        }\n        resetRotation() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            let hasRotate = false;\n            /**\n             * An unrolled check for rotation values. Most elements don't have any rotation and\n             * skipping the nested loop and new object creation is 50% faster.\n             */\n            const { latestValues } = visualElement;\n            if (latestValues.rotate ||\n                latestValues.rotateX ||\n                latestValues.rotateY ||\n                latestValues.rotateZ) {\n                hasRotate = true;\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            const resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (let i = 0; i < transformAxes.length; i++) {\n                const key = \"rotate\" + transformAxes[i];\n                // Record the rotation and then temporarily set it to 0\n                if (latestValues[key]) {\n                    resetValues[key] = latestValues[key];\n                    visualElement.setStaticValue(key, 0);\n                }\n            }\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.render();\n            // Put back all the values we reset\n            for (const key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        }\n        getProjectionStyles(styleProp = {}) {\n            var _a, _b, _c;\n            // TODO: Return lifecycle-persistent object\n            const styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            const transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            const lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                const emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity =\n                        this.latestValues.opacity !== undefined\n                            ? this.latestValues.opacity\n                            : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            const valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            const { x, y } = this.projectionDelta;\n            styles.transformOrigin = `${x.origin * 100}% ${y.origin * 100}% 0`;\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_c = (_b = valuesToRender.opacity) !== null && _b !== void 0 ? _b : this.latestValues.opacity) !== null && _c !== void 0 ? _c : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its layout\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? valuesToRender.opacity !== undefined\n                            ? valuesToRender.opacity\n                            : \"\"\n                        : valuesToRender.opacityExit !== undefined\n                            ? valuesToRender.opacityExit\n                            : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (const key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                const { correct, applyTo } = scaleCorrectors[key];\n                const corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    const num = applyTo.length;\n                    for (let i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        }\n        clearSnapshot() {\n            this.resumeFrom = this.snapshot = undefined;\n        }\n        // Only run on root\n        resetTree() {\n            this.root.nodes.forEach((node) => { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        }\n    };\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c;\n    const snapshot = ((_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) || node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        const { layoutBox: layout, measuredBox: measuredLayout } = node.layout;\n        const { animationType } = node.options;\n        const isShared = snapshot.source !== node.layout.source;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (animationType === \"size\") {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout)) {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(layout[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        const layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout, snapshot.layoutBox);\n        const visualDelta = createDelta();\n        if (isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measuredBox);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout, snapshot.layoutBox);\n        }\n        const hasLayoutChanged = !isDeltaZero(layoutDelta);\n        let hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            const relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (relativeParent && !relativeParent.resumeFrom) {\n                const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;\n                if (parentSnapshot && parentLayout) {\n                    const relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox);\n                    const relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout, parentLayout.layoutBox);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout,\n            snapshot,\n            delta: visualDelta,\n            layoutDelta,\n            hasLayoutChanged,\n            hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_c = (_b = node.options).onExitComplete) === null || _c === void 0 ? void 0 : _c.call(_b);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction propagateDirtyNodes(node) {\n    /**\n     * Propagate isProjectionDirty. Nodes are ordered by depth, so if the parent here\n     * is dirty we can simply pass this forward.\n     */\n    node.isProjectionDirty || (node.isProjectionDirty = Boolean(node.parent && node.parent.isProjectionDirty));\n    /**\n     * Propagate isTransformDirty.\n     */\n    node.isTransformDirty || (node.isTransformDirty = Boolean(node.parent && node.parent.isTransformDirty));\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    const { visualElement } = node.options;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notify(\"BeforeLayoutMeasure\");\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = mix(delta.translate, 0, p);\n    output.scale = mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = mix(from.min, to.min, p);\n    output.max = mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nconst defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, elementId) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    let searchNode = node.root;\n    for (let i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    const searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    const element = searchElement.querySelector(`[data-projection-id=\"${elementId}\"]`);\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\nfunction shouldAnimatePositionOnly(animationType, snapshot, layout) {\n    return (animationType === \"position\" ||\n        (animationType === \"preserve-aspect\" &&\n            !isNear(aspectRatio(snapshot), aspectRatio(layout), 0.2)));\n}\n\nexport { createProjectionNode, mixAxis, mixAxisDelta, mixBox, propagateDirtyNodes };\n","import { createMotionValueAnimation } from './index.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\n\n/**\n * Animate a single value or a `MotionValue`.\n *\n * The first argument is either a `MotionValue` to animate, or an initial animation value.\n *\n * The second is either a value to animate to, or an array of keyframes to animate through.\n *\n * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.\n *\n * Returns `AnimationPlaybackControls`, currently just a `stop` method.\n *\n * ```javascript\n * const x = useMotionValue(0)\n *\n * useEffect(() => {\n *   const controls = animate(x, 100, {\n *     type: \"spring\",\n *     stiffness: 2000,\n *     onComplete: v => {}\n *   })\n *\n *   return controls.stop\n * })\n * ```\n *\n * @public\n */\nfunction animate(from, to, transition = {}) {\n    const value = isMotionValue(from) ? from : motionValue(from);\n    value.start(createMotionValueAnimation(\"\", value, to, transition));\n    return {\n        stop: () => value.stop(),\n        isAnimating: () => value.isAnimating(),\n    };\n}\n\nexport { animate };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\n\nconst DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: (ref, notify) => addDomEvent(ref, \"resize\", notify),\n    measureScroll: () => ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }),\n    checkIsScrollRoot: () => true,\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nconst rootProjectionNode = {\n    current: undefined,\n};\nconst HTMLProjectionNode = createProjectionNode({\n    measureScroll: (instance) => ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }),\n    defaultParent: () => {\n        if (!rootProjectionNode.current) {\n            const 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: (instance, value) => {\n        instance.style.transform = value !== undefined ? value : \"none\";\n    },\n    checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === \"fixed\"),\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { 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 */\nconst domMax = {\n    ...domAnimation,\n    ...drag,\n    ...layoutFeatures,\n    projectionNodeConstructor: HTMLProjectionNode,\n};\n\nexport { domMax };\n"],"names":["isMouseEvent","event","PointerEvent","pointerType","MouseEvent","isTouchEvent","touches","defaultPagePoint","pageX","pageY","pointFromTouch","e","pointType","arguments","length","undefined","point","changedTouches","x","y","pointFromMouse","extractEventInfo","wrapHandler","handler","listener","eventHandler","button","secondsToMilliseconds","seconds","addDomEvent","target","eventName","options","passive","addEventListener","removeEventListener","useDomEvent","ref","useEffect","element","current","supportsPointerEvents","isBrowser","window","onpointerdown","supportsTouchEvents","ontouchstart","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","addPointerEvent","usePointerEvent","distance","a","b","Math","abs","PanSession","constructor","handlers","transformPagePoint","this","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","xDelta","yDelta","sqrt","distance2D","offset","timestamp","frameData","push","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","sync","update","end","onEnd","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","pipe","updateHandlers","cancelSync","subtractPoint","_ref","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","i","timestampedPoint","lastPoint","time","currentVelocity","Infinity","createLock","lock","openLock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal","openVertical","isDragActive","openGestureLock","calcLength","axis","max","min","isNear","value","maxDistance","calcAxisDelta","source","origin","originPoint","mix","scale","isNaN","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","AnimationType","createDelta","createBox","eachAxis","callback","convertBoundingBoxToBox","top","left","right","bottom","isIdentityScale","hasScale","scaleX","scaleY","hasTransform","values","has2DTranslate","z","rotate","rotateX","rotateY","is2DTranslate","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","snapToDefault","Number","isInteger","translateAxis","transformAxis","transforms","_ref2","key","scaleKey","originKey","axisOrigin","xKeys","yKeys","transformBox","transform","measureViewportBox","instance","topLeft","bottomRight","transformBoxPoints","getBoundingClientRect","instantAnimationState","cubicBezierAsString","c","d","concat","supportedWaapiEasing","linear","ease","easeIn","easeOut","easeInOut","circIn","circOut","backIn","backOut","mapEasingToNativeEasing","easing","Array","isArray","createAcceleratedAnimation","valueName","onUpdate","onComplete","keyframes","duration","elapsed","type","sampleAnimation","animate","state","done","pregeneratedKeyframes","t","sample","animation","delay","repeat","repeatType","times","fill","iterations","direction","animateStyle","owner","onfinish","set","currentTime","setWithVelocity","cancel","timeout","start","performance","now","checkElapsed","read","createInstantAnimation","setValue","underDampedSpring","stiffness","damping","restSpeed","criticallyDampedSpring","linearTween","keyframesTransition","defaultTransitions","rotateZ","opacity","backgroundColor","color","default","getDefaultTransition","valueKey","isAnimatable","complex","test","startsWith","maxDefaults","Set","applyDefaultFilter","v","slice","split","number","match","floatRegex","unit","replace","defaultValue","has","functionRegex","filter","getAnimatableNone","functions","map","join","defaultValueTypes","numberValueTypes","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","_a","defaultValueType","call","isZero","parseFloat","indexOf","getZeroUnit","potentialUnitType","getValueTransition","transition","featureTests","waapi","Object","hasOwnProperty","Element","prototype","results","supports","acceleratedValues","createMotionValueAnimation","valueTransition","isTargetAnimatable","from","get","getKeyframes","originKeyframe","targetKeyframe","isOriginAnimatable","warning","power","timeConstant","bounceStiffness","bounceDamping","restDelta","modifyTarget","driver","onStop","currentAnimation","isOutOfBounds","findNearestBoundary","startAnimation","stop","startSpring","boundary","heading","prev","checkBoundary","velocityPerSecond","inertia","when","_delay","delayChildren","staggerChildren","staggerDirection","repeatDelay","keys","isTransitionDefined","visualElement","HTMLElement","getProps","elementDragControls","WeakMap","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","snapToCursor","isPresent","panSession","stopAnimation","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","_b","getAxisMotionValue","percent","measuredAxis","layoutBox","animationState","setActive","Drag","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","getCurrentDirection","updateAxis","render","getTransformPagePoint","onDragEnd","_point","shouldDrag","axisValue","next","applyConstraints","dragConstraints","prevConstraints","isRefObject","resolveRefConstraints","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","invariant","constraintsBox","rootProjectionNode","viewportBox","scroll","measurePageBox","root","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","startAxisValueAnimation","Promise","all","then","dragKey","toUpperCase","externalMotionValue","getValue","initial","scalePositionWithinConstraints","boxProgress","latest","sourceLength","targetLength","progress","clamp","calcOrigin","transformTemplate","style","updateScroll","updateLayout","addListeners","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","stopLayoutUpdateListener","hasLayoutChanged","motionValue","props","makeRenderlessComponent","hook","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","useContext","MotionConfigContext","useUnmountEffect","dragControls","groupDragControls","useConstant","subscribe","usePresence","context","PresenceContext","onExitComplete","register","id","useId","safeToRemove","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","isCSSVariable","cssVariableRegex","maxDepth","getVariableValue","depth","token","fallback","exec","parseCSSVariable","resolved","getComputedStyle","getPropertyValue","trim","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","shadow","parse","template","createTransformer","xScale","yScale","averageScale","output","cssVariable","MeasureLayoutWithContext","React__default","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","addScaleCorrector","defaultScaleCorrectors","group","add","didUpdate","setOptions","globalProjectionState","hasEverUpdated","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","postRender","getStack","members","componentDidUpdate","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","SwitchLayoutGroupContext","shallowCompare","prevLength","isZeroValueString","testValueType","dimensionValueTypes","degrees","vw","vh","findDimensionValueType","find","valueTypes","findValueType","resolveVariant","definition","custom","resolveVariantFromProps","forEach","getCurrent","setMotionValue","hasValue","addValue","setTarget","transitionEnd","makeTargetAnimatable","resolveFinalValueInKeyframes","getOriginFromTransition","isWillChangeMotionValue","Boolean","isMotionValue","appearStoreId","handoffOptimizedAppearAnimation","MotionAppearAnimations","animationId","transformProps","delete","optimizedAppearDataAttribute","camelToDash","animateVariant","variant","transitionOverride","getAnimation","animateTarget","resolve","getChildAnimations","variantChildren","size","forwardDelay","animations","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","child","notify","animateChildren","first","last","willChange","animationTypeState","getState","valueTarget","shouldBlockAnimation","shouldReduceMotion","hasAnimated","appearId","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","variantPriorityOrder","Animate","InView","Focus","Hover","Tap","Exit","reversePriorityOrder","reverse","numAnimationTypes","animateList","resolvedDefinition","animateVisualElement","createAnimationState","createTypeState","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isActive","isInherited","manuallyAnimateOnMount","prevProp","isAnimationControls","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","isKeyframesTarget","blockInitialAnimation","fallbackAnimation","fallbackTarget","getBaseTarget","shouldAnimate","setAnimateFunction","makeAnimator","exit","presenceContext","createHoverEvent","isNodeOrChild","parentElement","observerCallbacks","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","thresholdNames","some","useIntersectionObserver","shouldObserve","margin","rootMargin","amount","once","threshold","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","_ref3","env","warnOnce","requestAnimationFrame","gestureAnimations","inView","whileInView","viewport","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","checkPointerEnd","onPointerUp","onPointerCancel","focus","whileFocus","onFocus","onBlur","hover","onHoverStart","onHoverEnd","whileHover","positionalKeys","isPositionalKey","setAndResetVelocity","to","isNumOrPxType","BoundingBoxDimension","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","transformPropOrder","positionalValues","width","paddingLeft","paddingRight","height","_ref4","_ref5","paddingTop","paddingBottom","_ref6","_ref7","_ref8","_ref9","_ref10","_ref11","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","fromType","toType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","scrollY","pageYOffset","convertedTarget","convertChangedValueTypes","changedKeys","originBbox","elementComputedStyle","display","setStaticValue","targetBbox","_ref12","scrollTo","unitConversion","hasPositionalKey","parseDomVariant","resolveCSSVariables","prefersReducedMotion","hasReducedMotionListener","featureNames","featureDefinitions","numFeatures","propEventHandlers","VisualElement","reducedMotionConfig","visualState","children","isVariantNode","isControllingVariants","Map","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","latestValues","triggerBuild","renderInstance","renderState","scheduleRender","baseTarget","initialValues","initialMotionValues","scrapeMotionValuesFromProps","_props","mount","removeFromVariantTree","addVariantChild","bindToMotionValue","matchMedia","motionMediaQuery","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","setProps","unmount","_c","clear","valueIsTransform","removeOnChange","on","latestValue","isTransformDirty","removeOnRenderRequest","other","sortInstanceNodePosition","loadFeatures","renderedProps","isStrict","preloadedFeatures","projectionId","ProjectionNodeConstructor","initialLayoutGroupConfig","features","isEnabled","Component","createElement","layoutScroll","alwaysMeasureLayout","animationType","initialPromotionConfig","build","measureInstanceViewportBox","getStaticValue","canMutate","makeTargetAnimatableFromInstance","nextValue","prevValue","existingValue","removeValue","updateMotionValuesFromProps","getVariant","variants","getClosestVariantNode","numVariantProps","variantProps","closestVariantNode","removeValueFromRenderState","readValue","readValueFromInstance","setBaseTarget","valueFromInitial","getBaseTargetFromProps","SubscriptionManager","_len","args","_key","DOMVisualElement","compareDocumentPosition","vars","isMounted","transformValues","transitionOrigin","getOrigin","newValueKeys","numNewValues","targetValue","checkTargetForNewValues","parsed","HTMLVisualElement","defaultType","computedStyle","buildHTMLStyles","styleProp","renderHTML","SVGVisualElement","super","isSVGTag","camelCaseAttributes","getAttribute","buildSVGAttrs","renderSVG","tagName","domAnimation","renderer","createDomVisualElement","isSVGComponent","enableHardwareAcceleration","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","noop","p","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","aspectRatio","NodeStack","addUniqueItem","removeItem","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","_d","_e","resumingFrom","removeLeadSnapshot","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","FlatTree","isDirty","transformAxes","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","elementId","isTreeAnimating","isProjectionDirty","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","propagateDirtyNodes","resolveTargetDelta","calcProjection","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","notifyListeners","subscriptionManager","hasListeners","SVGElement","cancelDelay","resizeUnblockUpdate","hasAnimatedSinceResize","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","preRender","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","mountNodeEarly","resetTransformStyle","notifyLayoutUpdate","flushSync","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measure","prevLayout","layoutCorrected","phase","needsMeasurement","isRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","removeTransform","pageBox","removeElementScroll","roundAxis","measuredBox","boxWithoutScroll","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","getLead","attemptToResolveRelativeTarget","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","isShared","canSkip","pendingAnimation","treePath","isSharedTransition","treeLength","applyTreeDeltas","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","follow","opacityExit","borderLabel","followRadius","leadRadius","mixValues","isAnimating","completeAnimation","applyTransformsToTarget","shouldAnimatePositionOnly","xLength","yLength","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","getProjectionStyles","styles","visibility","pointerEvents","resolveMotionValue","emptyStyles","valuesToRender","transformOrigin","scaleCorrectors","corrected","num","resetTree","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","searchNode","querySelector","round","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","domMax","projectionNodeConstructor","documentNode","position"],"sourceRoot":""}