{"version":3,"file":"static/js/608.0f437826.chunk.js","mappings":"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","sources":["../node_modules/framer-motion/dist/es/motion/features/Feature.mjs","../node_modules/framer-motion/dist/es/events/utils/is-primary-pointer.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/add-dom-event.mjs","../node_modules/framer-motion/dist/es/events/add-pointer-event.mjs","../node_modules/framer-motion/dist/es/utils/distance.mjs","../node_modules/framer-motion/dist/es/gestures/pan/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/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/easing/modifiers/mirror.mjs","../node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","../node_modules/framer-motion/dist/es/easing/ease.mjs","../node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","../node_modules/framer-motion/dist/es/easing/circ.mjs","../node_modules/framer-motion/dist/es/easing/back.mjs","../node_modules/framer-motion/dist/es/animation/utils/easing.mjs","../node_modules/framer-motion/dist/es/easing/anticipate.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/keyframes.mjs","../node_modules/framer-motion/dist/es/utils/offsets/time.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/find-spring.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/spring.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/index.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/decay.mjs","../node_modules/framer-motion/dist/es/animation/waapi/easing.mjs","../node_modules/framer-motion/dist/es/animation/waapi/supports.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/animation/waapi/utils/get-final-keyframe.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/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/gestures/drag/index.mjs","../node_modules/framer-motion/dist/es/gestures/pan/index.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/components/AnimatePresence/use-presence.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/debug/record.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/motion/features/drag.mjs","../node_modules/framer-motion/dist/es/motion/features/layout.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/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/animation/index.mjs","../node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs","../node_modules/framer-motion/dist/es/motion/features/animations.mjs","../node_modules/framer-motion/dist/es/gestures/hover.mjs","../node_modules/framer-motion/dist/es/gestures/focus.mjs","../node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","../node_modules/framer-motion/dist/es/gestures/press.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs","../node_modules/framer-motion/dist/es/motion/features/gestures.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/features-animation.mjs","../node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","../node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n","const isPrimaryPointer = (event) => {\n    if (event.pointerType === \"mouse\") {\n        return typeof event.button !== \"number\" || event.button <= 0;\n    }\n    else {\n        /**\n         * isPrimary is true for all mice buttons, whereas every touch point\n         * is regarded as its own input. So subsequent concurrent touch points\n         * will be false.\n         *\n         * Specifically match against false here as incomplete versions of\n         * PointerEvents in very old browser might have it set as undefined.\n         */\n        return event.isPrimary !== false;\n    }\n};\n\nexport { isPrimaryPointer };\n","import { isPrimaryPointer } from './utils/is-primary-pointer.mjs';\n\nfunction extractEventInfo(event, pointType = \"page\") {\n    return {\n        point: {\n            x: event[pointType + \"X\"],\n            y: event[pointType + \"Y\"],\n        },\n    };\n}\nconst addPointerInfo = (handler) => {\n    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));\n};\n\nexport { addPointerInfo, extractEventInfo };\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","function addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n\nexport { addDomEvent };\n","import { addDomEvent } from './add-dom-event.mjs';\nimport { addPointerInfo } from './event-info.mjs';\n\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, eventName, addPointerInfo(handler), options);\n}\n\nexport { addPointerEvent };\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 { extractEventInfo } from '../../events/event-info.mjs';\nimport { sync, cancelSync } from '../../frameloop/index.mjs';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { distance2D } from '../../utils/distance.mjs';\nimport { frameData } from '../../frameloop/data.mjs';\nimport { isPrimaryPointer } from '../../events/utils/is-primary-pointer.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            // Throttle mouse move event to once per frame\n            sync.update(this.updatePoint, true);\n        };\n        this.handlePointerUp = (event, info) => {\n            this.end();\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const { onEnd, onSessionEnd } = this.handlers;\n            const panInfo = getPanInfo(event.type === \"pointercancel\"\n                ? this.lastMoveEventInfo\n                : 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 (!isPrimaryPointer(event))\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 ? origin.originX : undefined);\n    calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : undefined);\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","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    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        /**\n         * TODO: Prefer to remove this, but currently we have motion components with\n         * display: contents in Framer.\n         */\n        const instance = node.instance;\n        if (instance &&\n            instance.style &&\n            instance.style.display === \"contents\") {\n            continue;\n        }\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","// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\nexport { mirrorEasing };\n","// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = (easing) => (p) => 1 - easing(1 - p);\n\nexport { reverseEasing };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst easeIn = (p) => p * p;\nconst easeOut = reverseEasing(easeIn);\nconst easeInOut = mirrorEasing(easeIn);\n\nexport { easeIn, easeInOut, easeOut };\n","import { noop } from '../utils/noop.mjs';\n\n/*\n  Bezier function generator\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *\n    t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noop;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst circIn = (p) => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\n\nexport { circIn, circInOut, circOut };\n","import { cubicBezier } from './cubic-bezier.mjs';\nimport { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst backOut = cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = reverseEasing(backOut);\nconst backInOut = mirrorEasing(backIn);\n\nexport { backIn, backInOut, backOut };\n","import { invariant } from '../../utils/errors.mjs';\nimport { cubicBezier } from '../../easing/cubic-bezier.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { easeIn, easeInOut, easeOut } from '../../easing/ease.mjs';\nimport { circIn, circInOut, circOut } from '../../easing/circ.mjs';\nimport { backIn, backInOut, backOut } from '../../easing/back.mjs';\nimport { anticipate } from '../../easing/anticipate.mjs';\n\nconst easingLookup = {\n    linear: noop,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n};\nconst easingDefinitionToFunction = (definition) => {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);\n        const [x1, y1, x2, y2] = definition;\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, `Invalid easing type '${definition}'`);\n        return easingLookup[definition];\n    }\n    return definition;\n};\nconst isEasingArray = (ease) => {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { easingDefinitionToFunction, isEasingArray };\n","import { backIn } from './back.mjs';\n\nconst anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n\nexport { anticipate };\n","import { easeInOut } from '../../easing/ease.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../../utils/offsets/time.mjs';\nimport { isEasingArray, easingDefinitionToFunction } from '../utils/easing.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ keyframes: keyframeValues, ease = easeInOut, times, duration = 300, }) {\n    keyframeValues = [...keyframeValues];\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    function createInterpolator() {\n        return interpolate(absoluteTimes, keyframeValues, {\n            ease: Array.isArray(easingFunctions)\n                ? easingFunctions\n                : defaultEasing(keyframeValues, easingFunctions),\n        });\n    }\n    let interpolator = createInterpolator();\n    return {\n        next: (t) => {\n            state.value = interpolator(t);\n            state.done = t >= duration;\n            return state;\n        },\n        flipTarget: () => {\n            keyframeValues.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n","function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n","import { warning } from '../../utils/errors.mjs';\nimport { clamp } from '../../utils/clamp.mjs';\n\nconst safeMin = 0.001;\nconst minDuration = 0.01;\nconst maxDuration = 10.0;\nconst minDamping = 0.05;\nconst maxDamping = 1;\nfunction findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= maxDuration * 1000, \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = duration * 1000;\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: 100,\n            damping: 10,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };\n","import { findSpring, calcAngularFreq } from './find-spring.mjs';\nimport { velocityPerSecond } from '../../utils/velocity-per-second.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            velocity: 0.0,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nconst velocitySampleDuration = 5;\n/**\n * This is based on the spring implementation of Wobble https://github.com/skevy/wobble\n */\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    let origin = keyframes[0];\n    let target = keyframes[keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    let resolveSpring = zero;\n    let initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    function createSpring() {\n        const initialDelta = target - origin;\n        const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        /**\n         * If we're working on a granular scale, use smaller defaults for determining\n         * when the spring is finished.\n         *\n         * These defaults have been selected emprically based on what strikes a good\n         * ratio between feeling good and finishing as soon as changes are imperceptible.\n         */\n        const isGranularScale = Math.abs(initialDelta) < 5;\n        restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);\n        restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\n        if (dampingRatio < 1) {\n            const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            // Underdamped spring\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (target -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq) *\n                            Math.sin(angularFreq * t) +\n                            initialDelta * Math.cos(angularFreq * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            // Critically damped spring\n            resolveSpring = (t) => target -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta +\n                        (initialVelocity + undampedAngularFreq * initialDelta) *\n                            t);\n        }\n        else {\n            // Overdamped spring\n            const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                // When performing sinh or cosh values can hit Infinity so we cap them here\n                const freqForT = Math.min(dampedAngularFreq * t, 300);\n                return (target -\n                    (envelope *\n                        ((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) *\n                            Math.sinh(freqForT) +\n                            dampedAngularFreq *\n                                initialDelta *\n                                Math.cosh(freqForT))) /\n                        dampedAngularFreq);\n            };\n        }\n    }\n    createSpring();\n    return {\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 0) {\n                    /**\n                     * We only need to calculate velocity for under-damped springs\n                     * as over- and critically-damped springs can't overshoot, so\n                     * checking only for displacement is enough.\n                     */\n                    if (dampingRatio < 1) {\n                        const prevT = Math.max(0, t - velocitySampleDuration);\n                        currentVelocity = velocityPerSecond(current - resolveSpring(prevT), t - prevT);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        flipTarget: () => {\n            initialVelocity = -initialVelocity;\n            [origin, target] = [target, origin];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = (a, b) => typeof a === \"string\" || typeof b === \"string\";\nconst zero = (_t) => 0;\n\nexport { spring };\n","import { keyframes } from './keyframes.mjs';\nimport { spring } from './spring.mjs';\nimport { decay } from './decay.mjs';\nimport { sync, cancelSync } from '../../frameloop/index.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\n\nconst types = {\n    decay,\n    keyframes: keyframes,\n    tween: keyframes,\n    spring,\n};\nfunction loopElapsed(elapsed, duration, delay = 0) {\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration = 0, delay = 0, isForwardPlayback = true) {\n    return isForwardPlayback\n        ? loopElapsed(duration + -elapsed, duration, delay)\n        : duration - (elapsed - duration) + delay;\n}\nfunction hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {\n    return isForwardPlayback ? elapsed >= duration + delay : elapsed <= -delay;\n}\nconst framesync = (update) => {\n    const passTimestamp = ({ delta }) => update(delta);\n    return {\n        start: () => sync.update(passTimestamp, true),\n        stop: () => cancelSync.update(passTimestamp),\n    };\n};\nfunction animateValue({ duration, driver = framesync, elapsed = 0, repeat: repeatMax = 0, repeatType = \"loop\", repeatDelay = 0, keyframes: keyframes$1, autoplay = true, onPlay, onStop, onComplete, onRepeat, onUpdate, type = \"keyframes\", ...options }) {\n    const initialElapsed = elapsed;\n    let driverControls;\n    let repeatCount = 0;\n    let computedDuration = duration;\n    let isComplete = false;\n    let isForwardPlayback = true;\n    let interpolateFromNumber;\n    const animator = types[keyframes$1.length > 2 ? \"keyframes\" : type] || keyframes;\n    const origin = keyframes$1[0];\n    const target = keyframes$1[keyframes$1.length - 1];\n    let state = { done: false, value: origin };\n    /**\n     * If this value needs interpolation (ie is non-numerical), set up an interpolator.\n     * TODO: Keyframes animation also performs this step. This could be removed so it only happens here.\n     */\n    const { needsInterpolation } = animator;\n    if (needsInterpolation && needsInterpolation(origin, target)) {\n        interpolateFromNumber = interpolate([0, 100], [origin, target], {\n            clamp: false,\n        });\n        keyframes$1 = [0, 100];\n    }\n    const animation = animator({\n        ...options,\n        duration,\n        keyframes: keyframes$1,\n    });\n    function repeat() {\n        repeatCount++;\n        if (repeatType === \"reverse\") {\n            isForwardPlayback = repeatCount % 2 === 0;\n            elapsed = reverseElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback);\n        }\n        else {\n            elapsed = loopElapsed(elapsed, computedDuration, repeatDelay);\n            if (repeatType === \"mirror\")\n                animation.flipTarget();\n        }\n        isComplete = false;\n        onRepeat && onRepeat();\n    }\n    function complete() {\n        driverControls && driverControls.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            state = animation.next(Math.max(0, elapsed));\n            if (interpolateFromNumber)\n                state.value = interpolateFromNumber(state.value);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate && onUpdate(state.value);\n        if (isComplete) {\n            if (repeatCount === 0) {\n                computedDuration =\n                    computedDuration !== undefined ? computedDuration : elapsed;\n            }\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay && onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: () => {\n            onStop && onStop();\n            driverControls && driverControls.stop();\n        },\n        /**\n         * Set the current time of the animation. This is purposefully\n         * mirroring the WAAPI animation API to make them interchanagable.\n         * Going forward this file should be ported more towards\n         * https://github.com/motiondivision/motionone/blob/main/packages/animation/src/Animation.ts\n         * Which behaviourally adheres to WAAPI as far as possible.\n         *\n         * WARNING: This is not safe to use for most animations. We currently\n         * only use it for handoff from WAAPI within Framer.\n         *\n         * This animation function consumes time every frame rather than being sampled for time.\n         * So the sample() method performs some headless frames to ensure\n         * repeats are handled correctly. Ideally in the future we will replace\n         * that method with this, once repeat calculations are pure.\n         */\n        set currentTime(t) {\n            elapsed = initialElapsed;\n            update(t);\n        },\n        /**\n         * animate() can't yet be sampled for time, instead it\n         * consumes time. So to sample it we have to run a low\n         * temporal-resolution version.\n         */\n        sample: (t) => {\n            elapsed = initialElapsed;\n            const sampleResolution = duration && typeof duration === \"number\"\n                ? Math.max(duration * 0.5, 50)\n                : 50;\n            let sampleElapsed = 0;\n            update(0);\n            while (sampleElapsed <= t) {\n                const remaining = t - sampleElapsed;\n                update(Math.min(remaining, sampleResolution));\n                sampleElapsed += sampleResolution;\n            }\n            return state;\n        },\n    };\n}\n\nexport { animateValue, hasRepeatDelayElapsed, loopElapsed, reverseElapsed };\n","function decay({ \n/**\n * The decay animation dynamically calculates an end of the animation\n * based on the initial keyframe, so we only need to define a single keyframe\n * as default.\n */\nkeyframes = [0], velocity = 0, power = 0.8, timeConstant = 350, restDelta = 0.5, modifyTarget, }) {\n    const origin = keyframes[0];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    return {\n        next: (t) => {\n            const delta = -amplitude * Math.exp(-t / timeConstant);\n            state.done = !(delta > restDelta || delta < -restDelta);\n            state.value = state.done ? target : target + delta;\n            return state;\n        },\n        flipTarget: () => { },\n    };\n}\n\nexport { decay };\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","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 { sync } from '../../frameloop/index.mjs';\nimport { animateValue } from '../legacy-popmotion/index.mjs';\nimport { animateStyle } from './index.mjs';\nimport { isWaapiSupportedEasing } from './easing.mjs';\nimport { supports } from './supports.mjs';\nimport { getFinalKeyframe } from './utils/get-final-keyframe.mjs';\n\n/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\n    \"opacity\",\n    \"clipPath\",\n    \"filter\",\n    \"transform\",\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    const canAccelerateAnimation = supports.waapi() &&\n        acceleratedValues.has(valueName) &&\n        !options.repeatDelay &&\n        options.repeatType !== \"mirror\" &&\n        options.damping !== 0;\n    if (!canAccelerateAnimation)\n        return false;\n    let { keyframes, duration = 300, 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        /**\n         * If we need to pre-generate keyframes and repeat is infinite then\n         * early return as this will lock the thread.\n         */\n        if (options.repeat === Infinity)\n            return;\n        const sampleAnimation = animateValue({ ...options, elapsed: 0 });\n        let state = { done: false, value: keyframes[0] };\n        const pregeneratedKeyframes = [];\n        /**\n         * Bail after 20 seconds of pre-generated keyframes as it's likely\n         * we're heading for an infinite loop.\n         */\n        let t = 0;\n        while (!state.done && t < 20000) {\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(getFinalKeyframe(keyframes, options));\n        sync.update(() => animation.cancel());\n        onComplete && onComplete();\n    };\n    /**\n     * Animation interrupt callback.\n     */\n    return {\n        get currentTime() {\n            return animation.currentTime || 0;\n        },\n        set currentTime(t) {\n            animation.currentTime = t;\n        },\n        stop: () => {\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 = animateValue({\n                    ...options,\n                    autoplay: false,\n                });\n                value.setWithVelocity(sampleAnimation.sample(currentTime - sampleDelta).value, sampleAnimation.sample(currentTime).value, sampleDelta);\n            }\n            sync.update(() => animation.cancel());\n        },\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","function getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }) {\n    const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1\n        ? 0\n        : keyframes.length - 1;\n    return keyframes[index];\n}\n\nexport { getFinalKeyframe };\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    };\n    return elapsed ? { stop: delay(setValue, -elapsed) } : setValue();\n}\n\nexport { createInstantAnimation };\n","import { transformProps } from '../../render/html/utils/transform.mjs';\n\nconst 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 keyframesTransition = {\n    type: \"keyframes\",\n    duration: 0.8,\n};\n/**\n * Default easing curve is a slightly shallower version of\n * the default browser easing curve.\n */\nconst ease = {\n    type: \"keyframes\",\n    ease: [0.25, 0.1, 0.35, 1],\n    duration: 0.3,\n};\nconst getDefaultTransition = (valueKey, { keyframes }) => {\n    if (keyframes.length > 2) {\n        return keyframesTransition;\n    }\n    else if (transformProps.has(valueKey)) {\n        return valueKey.startsWith(\"scale\")\n            ? criticallyDampedSpring(keyframes[1])\n            : underDampedSpring;\n    }\n    return ease;\n};\n\nexport { getDefaultTransition };\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    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 defaultValueType.getAnimatableNone\n        ? defaultValueType.getAnimatableNone(value)\n        : undefined;\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, elapsed, ...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","import { warning } from '../utils/errors.mjs';\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 { animateValue } 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';\n\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            return inertia(options);\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        /**\n         * Animate via WAAPI if possible.\n         */\n        if (value.owner &&\n            value.owner.current instanceof HTMLElement &&\n            !value.owner.getProps().onUpdate) {\n            const acceleratedAnimation = createAcceleratedAnimation(value, valueName, options);\n            if (acceleratedAnimation)\n                return acceleratedAnimation;\n        }\n        /**\n         * If we didn't create an accelerated animation, create a JS animation\n         */\n        return animateValue(options);\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 { animateValue } 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 && currentAnimation.stop();\n        currentAnimation = animateValue({\n            keyframes: [0, 1],\n            velocity: 0,\n            ...options,\n            driver,\n            onUpdate: (v) => {\n                onUpdate && onUpdate(v);\n                options.onUpdate && options.onUpdate(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 && currentAnimation.stop(),\n    };\n}\n\nexport { inertia };\n","import { invariant } from '../../utils/errors.mjs';\nimport { PanSession } from '../pan/PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, calcOrigin } from './utils/constraints.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/add-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: PointerEvent\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        const { presenceContext } = this.visualElement;\n        if (presenceContext && presenceContext.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            // 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                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 { projection } = this.visualElement;\n                    if (projection && projection.layout) {\n                        const measuredAxis = projection.layout.layoutBox[axis];\n                        if (measuredAxis) {\n                            const length = calcLength(measuredAxis);\n                            current = length * (parseFloat(current) / 100);\n                        }\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart && onDragStart(event, info);\n            const { animationState } = this.visualElement;\n            animationState && animationState.setActive(\"whileDrag\", 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 && 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 && 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 && onDragEnd(event, info);\n    }\n    cancel() {\n        this.isDragging = false;\n        const { projection, animationState } = this.visualElement;\n        if (projection) {\n            projection.isAnimationBlocked = false;\n        }\n        this.panSession && this.panSession.end();\n        this.panSession = undefined;\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        animationState && animationState.setActive(\"whileDrag\", 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 && 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        const dragKey = \"_drag\" + axis.toUpperCase();\n        const props = this.visualElement.getProps();\n        const externalMotionValue = props[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (props.initial ? props.initial[axis] : undefined) || 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        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        projection.root && projection.root.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        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            projection.root && projection.root.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 && 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","import { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\n\nclass DragGesture extends Feature {\n    constructor(node) {\n        super(node);\n        this.removeGroupControls = noop;\n        this.removeListeners = noop;\n        this.controls = new VisualElementDragControls(node);\n    }\n    mount() {\n        // If we've been provided a DragControls for manual control over the drag gesture,\n        // subscribe this component to it on mount.\n        const { dragControls } = this.node.getProps();\n        if (dragControls) {\n            this.removeGroupControls = dragControls.subscribe(this.controls);\n        }\n        this.removeListeners = this.controls.addListeners() || noop;\n    }\n    unmount() {\n        this.removeGroupControls();\n        this.removeListeners();\n    }\n}\n\nexport { DragGesture };\n","import { PanSession } from './PanSession.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\n\nclass PanGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removePointerDownListener = noop;\n    }\n    onPointerDown(pointerDownEvent) {\n        this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), { transformPagePoint: this.node.getTransformPagePoint() });\n    }\n    createPanHandlers() {\n        const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();\n        return {\n            onSessionStart: onPanSessionStart,\n            onStart: onPanStart,\n            onMove: onPan,\n            onEnd: (event, info) => {\n                delete this.session;\n                onPanEnd && onPanEnd(event, info);\n            },\n        };\n    }\n    mount() {\n        this.removePointerDownListener = addPointerEvent(this.node.current, \"pointerdown\", (event) => this.onPointerDown(event));\n    }\n    update() {\n        this.session && this.session.updateHandlers(this.createPanHandlers());\n    }\n    unmount() {\n        this.removePointerDownListener();\n        this.session && this.session.end();\n    }\n}\n\nexport { PanGesture };\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 '../../../utils/errors.mjs';\nimport { isCSSVariableToken } from './is-css-variable.mjs';\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 (isCSSVariableToken(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 (!isCSSVariableToken(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 (!isCSSVariableToken(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                    const stack = projection.getStack();\n                    if (!stack || !stack.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 && layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext && promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    }\n    safeToRemove() {\n        const { safeToRemove } = this.props;\n        safeToRemove && 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 { 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    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 { 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 ? originBox.x : undefined, sourceBox ? sourceBox.x : undefined);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : undefined, sourceBox ? sourceBox.y : undefined);\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        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 (node.root && node.root.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            const { options, resumingFrom } = node;\n            options.onExitComplete && options.onExitComplete();\n            if (resumingFrom) {\n                resumingFrom.options.onExitComplete &&\n                    resumingFrom.options.onExitComplete();\n            }\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';\nimport { record } from '../../debug/record.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;\n/**\n * Use a mutable data object for debug data so as to not create a new\n * object every frame.\n */\nconst projectionFrameData = {\n    type: \"projectionFrame\",\n    totalNodes: 0,\n    resolvedTargetDeltas: 0,\n    recalculatedProjection: 0,\n};\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            /**\n             * Flag to true if we think the projection calculations for this node needs\n             * recalculating as a result of an updated transform or layout animation.\n             */\n            this.isProjectionDirty = false;\n            /**\n             * Flag to true if the layout *or* transform has changed. This then gets propagated\n             * throughout the projection tree, forcing any element below to recalculate on the next frame.\n             */\n            this.isSharedProjectionDirty = false;\n            /**\n             * Flag transform dirty. This gets propagated throughout the whole tree but is only\n             * respected by shared nodes.\n             */\n            this.isTransformDirty = 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                /**\n                 * Reset debug counts. Manually resetting rather than creating a new\n                 * object each frame.\n                 */\n                projectionFrameData.totalNodes =\n                    projectionFrameData.resolvedTargetDeltas =\n                        projectionFrameData.recalculatedProjection =\n                            0;\n                this.nodes.forEach(propagateDirtyNodes);\n                this.nodes.forEach(resolveTargetDelta);\n                this.nodes.forEach(calcProjection);\n                this.nodes.forEach(cleanDirtyNodes);\n                record(projectionFrameData);\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 && 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            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            this.parent && this.parent.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                    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 = this.options.transition ||\n                        visualElement.getDefaultTransition() ||\n                        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 (this.options.layoutRoot ||\n                        (this.resumeFrom && this.resumeFrom.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                            this.options.layoutRoot) {\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                        if (this.isLead() && this.options.onExitComplete) {\n                            this.options.onExitComplete();\n                        }\n                    }\n                    this.targetLayout = newLayout;\n                });\n            }\n        }\n        unmount() {\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            const stack = this.getStack();\n            stack && stack.remove(this);\n            this.parent && this.parent.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            return (this.isAnimationBlocked ||\n                (this.parent && this.parent.isTreeAnimationBlocked()) ||\n                false);\n        }\n        // Note: currently only running on root node\n        startUpdate() {\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            this.nodes && this.nodes.forEach(resetRotation);\n            this.animationId++;\n        }\n        getTransformTemplate() {\n            const { visualElement } = this.options;\n            return visualElement && visualElement.getProps().transformTemplate;\n        }\n        willUpdate(shouldNotifyListeners = true) {\n            if (this.root.isUpdateBlocked()) {\n                this.options.onExitComplete && this.options.onExitComplete();\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                if (node.options.layoutRoot) {\n                    node.willUpdate(false);\n                }\n            }\n            const { layoutId, layout } = this.options;\n            if (layoutId === undefined && !layout)\n                return;\n            const transformTemplate = this.getTransformTemplate();\n            this.prevTransformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\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            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            const { visualElement } = this.options;\n            visualElement &&\n                visualElement.notify(\"LayoutMeasure\", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : undefined);\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            if (!resetTransform)\n                return;\n            const isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            const transformTemplate = this.getTransformTemplate();\n            const transformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\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            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, node.snapshot ? node.snapshot.layoutBox : undefined, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        }\n        setTargetDelta(delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n            this.isProjectionDirty = true;\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            this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\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            const canSkip = !((isShared && this.isSharedProjectionDirty) ||\n                this.isProjectionDirty ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty) ||\n                this.attemptToResolveRelativeTarget);\n            if (canSkip)\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                this.relativeParent &&\n                this.relativeParent.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             * Increase debug counter for resolved target deltas\n             */\n            projectionFrameData.resolvedTargetDeltas++;\n        }\n        getClosestProjectingParent() {\n            if (!this.parent ||\n                hasScale(this.parent.latestValues) ||\n                has2DTranslate(this.parent.latestValues)) {\n                return undefined;\n            }\n            if (this.parent.isProjecting()) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        }\n        isProjecting() {\n            return Boolean((this.relativeTarget ||\n                this.targetDelta ||\n                this.options.layoutRoot) &&\n                this.layout);\n        }\n        calcProjection() {\n            var _a;\n            const lead = this.getLead();\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            let canSkip = true;\n            /**\n             * If this is a normal layout animation and neither this node nor its nearest projecting\n             * is dirty then we can't skip.\n             */\n            if (this.isProjectionDirty || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty)) {\n                canSkip = false;\n            }\n            /**\n             * If this is a shared layout animation and this node's shared projection is dirty then\n             * we can't skip.\n             */\n            if (isShared &&\n                (this.isSharedProjectionDirty || this.isTransformDirty)) {\n                canSkip = false;\n            }\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((this.parent && this.parent.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             * Increase debug counter for recalculated projections\n             */\n            projectionFrameData.recalculatedProjection++;\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            this.options.scheduleRender && this.options.scheduleRender();\n            if (notifyAll) {\n                const stack = this.getStack();\n                stack && stack.scheduleRender();\n            }\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        }\n        setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {\n            const snapshot = this.snapshot;\n            const snapshotLatestValues = snapshot\n                ? snapshot.latestValues\n                : {};\n            const mixedValues = { ...this.latestValues };\n            const targetDelta = createDelta();\n            if (!this.relativeParent ||\n                !this.relativeParent.options.layoutRoot) {\n                this.relativeTarget = this.relativeTargetOrigin = undefined;\n            }\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            const relativeLayout = createBox();\n            const snapshotSource = snapshot ? snapshot.source : undefined;\n            const layoutSource = this.layout ? this.layout.source : undefined;\n            const isSharedLayoutAnimation = snapshotSource !== layoutSource;\n            const stack = this.getStack();\n            const isOnlyMember = !stack || stack.members.length <= 1;\n            const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            let prevRelativeTarget;\n            this.mixTargetDelta = (latest) => {\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                    this.relativeParent &&\n                    this.relativeParent.layout) {\n                    calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);\n                    mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);\n                    /**\n                     * If this is an unchanged relative target we can consider the\n                     * projection not dirty.\n                     */\n                    if (prevRelativeTarget &&\n                        boxEquals(this.relativeTarget, prevRelativeTarget)) {\n                        this.isProjectionDirty = false;\n                    }\n                    if (!prevRelativeTarget)\n                        prevRelativeTarget = createBox();\n                    copyBoxInto(prevRelativeTarget, this.relativeTarget);\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(this.options.layoutRoot ? 1000 : 0);\n        }\n        startAnimation(options) {\n            this.notifyListeners(\"animationStart\");\n            this.currentAnimation && this.currentAnimation.stop();\n            if (this.resumingFrom && this.resumingFrom.currentAnimation) {\n                this.resumingFrom.currentAnimation.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                        this.mixTargetDelta(latest);\n                        options.onUpdate && options.onUpdate(latest);\n                    },\n                    onComplete: () => {\n                        options.onComplete && options.onComplete();\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            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            const stack = this.getStack();\n            stack && stack.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        }\n        finishAnimation() {\n            if (this.currentAnimation) {\n                this.mixTargetDelta && this.mixTargetDelta(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            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            const config = node.options.initialPromotionConfig;\n            node.promote({\n                transition: config ? config.transition : undefined,\n                preserveFollowOpacity: config && config.shouldPreserveFollowOpacity\n                    ? config.shouldPreserveFollowOpacity(node)\n                    : undefined,\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.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;\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 = this.getTransformTemplate();\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                        ? (_b = (_a = valuesToRender.opacity) !== null && _a !== void 0 ? _a : this.latestValues.opacity) !== null && _b !== void 0 ? _b : 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                /**\n                 * Only apply scale correction to the value if we have an\n                 * active projection transform. Otherwise these values become\n                 * vulnerable to distortion if the element changes size without\n                 * a corresponding layout animation.\n                 */\n                const corrected = styles.transform === \"none\"\n                    ? valuesToRender[key]\n                    : 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;\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                    if (relativeParent.options.layoutRoot) {\n                        node.relativeTarget = relativeLayout;\n                        node.relativeTargetOrigin = relativeSnapshot;\n                        node.relativeParent = relativeParent;\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        const { onExitComplete } = node.options;\n        onExitComplete && onExitComplete();\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     * Increase debug counter for nodes encountered this frame\n     */\n    projectionFrameData.totalNodes++;\n    if (!node.parent)\n        return;\n    /**\n     * If this node isn't projecting, propagate isProjectionDirty. It will have\n     * no performance impact but it will allow the next child that *is* projecting\n     * but *isn't* dirty to just check its parent to see if *any* ancestor needs\n     * correcting.\n     */\n    if (!node.isProjecting()) {\n        node.isProjectionDirty = node.parent.isProjectionDirty;\n    }\n    /**\n     * Propagate isSharedProjectionDirty and isTransformDirty\n     * throughout the whole tree. A future revision can take another look at\n     * this but for safety we still recalcualte shared nodes.\n     */\n    node.isSharedProjectionDirty || (node.isSharedProjectionDirty = Boolean(node.isProjectionDirty ||\n        node.parent.isProjectionDirty ||\n        node.parent.isSharedProjectionDirty));\n    node.isTransformDirty || (node.isTransformDirty = node.parent.isTransformDirty);\n}\nfunction cleanDirtyNodes(node) {\n    node.isProjectionDirty =\n        node.isSharedProjectionDirty =\n            node.isTransformDirty =\n                false;\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 && 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 { cleanDirtyNodes, createProjectionNode, mixAxis, mixAxisDelta, mixBox, propagateDirtyNodes };\n","function record(data) {\n    if (window.MotionDebug) {\n        window.MotionDebug.record(data);\n    }\n}\n\nexport { record };\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/add-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 { DragGesture } from '../../gestures/drag/index.mjs';\nimport { PanGesture } from '../../gestures/pan/index.mjs';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\nconst drag = {\n    pan: {\n        Feature: PanGesture,\n    },\n    drag: {\n        Feature: DragGesture,\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { drag };\n","import { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\n\nconst layout = {\n    layout: {\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { layout };\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        const variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        if (visualElement.variantChildren) {\n            visualElement.variantChildren.forEach((child) => {\n                setVariants(child, variantLabels);\n            });\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    const origin = {};\n    for (const key in target) {\n        const transitionOrigin = getOriginFromTransition(key, transition);\n        if (transitionOrigin !== undefined) {\n            origin[key] = transitionOrigin;\n        }\n        else {\n            const value = visualElement.getValue(key);\n            if (value) {\n                origin[key] = value.get();\n            }\n        }\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","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 { optimizedAppearDataAttribute } from '../../animation/optimized-appear/data-id.mjs';\nimport { createMotionValueAnimation } from '../../animation/index.mjs';\nimport { sync } from '../../frameloop/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    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 = visualElement.variantChildren && visualElement.variantChildren.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    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 &&\n        visualElement.animationState &&\n        visualElement.animationState.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        const valueTransition = { delay, elapsed: 0, ...transition };\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 (window.HandoffAppearAnimations && !value.hasAnimated) {\n            const appearId = visualElement.getProps()[optimizedAppearDataAttribute];\n            if (appearId) {\n                valueTransition.elapsed = window.HandoffAppearAnimations(appearId, key, value, sync);\n            }\n        }\n        let animation = value.start(createMotionValueAnimation(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key)\n            ? { type: false }\n            : 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        child.notify(\"AnimationStart\", variant);\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 { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\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        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n","import { isAnimationControls } from '../../../animation/utils/is-animation-controls.mjs';\nimport { createAnimationState } from '../../../render/utils/animation-state.mjs';\nimport { Feature } from '../Feature.mjs';\n\nclass AnimationFeature extends Feature {\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    constructor(node) {\n        super(node);\n        node.animationState || (node.animationState = createAnimationState(node));\n    }\n    updateAnimationControlsSubscription() {\n        const { animate } = this.node.getProps();\n        this.unmount();\n        if (isAnimationControls(animate)) {\n            this.unmount = animate.subscribe(this.node);\n        }\n    }\n    /**\n     * Subscribe any provided AnimationControls to the component's VisualElement\n     */\n    mount() {\n        this.updateAnimationControlsSubscription();\n    }\n    update() {\n        const { animate } = this.node.getProps();\n        const { animate: prevAnimate } = this.node.prevProps || {};\n        if (animate !== prevAnimate) {\n            this.updateAnimationControlsSubscription();\n        }\n    }\n    unmount() { }\n}\n\nexport { AnimationFeature };\n","import { Feature } from '../Feature.mjs';\n\nlet id = 0;\nclass ExitAnimationFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.id = id++;\n    }\n    update() {\n        if (!this.node.presenceContext)\n            return;\n        const { isPresent, onExitComplete, custom } = this.node.presenceContext;\n        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};\n        if (!this.node.animationState || isPresent === prevIsPresent) {\n            return;\n        }\n        const exitAnimation = this.node.animationState.setActive(\"exit\", !isPresent, { custom: custom !== null && custom !== void 0 ? custom : this.node.getProps().custom });\n        if (onExitComplete && !isPresent) {\n            exitAnimation.then(() => onExitComplete(this.id));\n        }\n    }\n    mount() {\n        const { register } = this.node.presenceContext || {};\n        if (register) {\n            this.unmount = register(this.id);\n        }\n    }\n    unmount() { }\n}\n\nexport { ExitAnimationFeature };\n","import { AnimationFeature } from './animation/index.mjs';\nimport { ExitAnimationFeature } from './animation/exit.mjs';\n\nconst animations = {\n    animation: {\n        Feature: AnimationFeature,\n    },\n    exit: {\n        Feature: ExitAnimationFeature,\n    },\n};\n\nexport { animations };\n","import { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\n\nfunction addHoverEvent(node, isActive) {\n    const eventName = \"pointer\" + (isActive ? \"enter\" : \"leave\");\n    const callbackName = \"onHover\" + (isActive ? \"Start\" : \"End\");\n    const handleEvent = (event, info) => {\n        if (event.type === \"touch\" || isDragActive())\n            return;\n        const props = node.getProps();\n        if (node.animationState && props.whileHover) {\n            node.animationState.setActive(\"whileHover\", isActive);\n        }\n        if (props[callbackName]) {\n            props[callbackName](event, info);\n        }\n    };\n    return addPointerEvent(node.current, eventName, handleEvent, {\n        passive: !node.getProps()[callbackName],\n    });\n}\nclass HoverGesture extends Feature {\n    mount() {\n        this.unmount = pipe(addHoverEvent(this.node, true), addHoverEvent(this.node, false));\n    }\n    unmount() { }\n}\n\nexport { HoverGesture };\n","import { addDomEvent } from '../events/add-dom-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\n\nclass FocusGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.isActive = false;\n    }\n    onFocus() {\n        let isFocusVisible = false;\n        /**\n         * If this element doesn't match focus-visible then don't\n         * apply whileHover. But, if matches throws that focus-visible\n         * is not a valid selector then in that browser outline styles will be applied\n         * to the element by default and we want to match that behaviour with whileFocus.\n         */\n        try {\n            isFocusVisible = this.node.current.matches(\":focus-visible\");\n        }\n        catch (e) {\n            isFocusVisible = true;\n        }\n        if (!isFocusVisible || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", true);\n        this.isActive = true;\n    }\n    onBlur() {\n        if (!this.isActive || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", false);\n        this.isActive = false;\n    }\n    mount() {\n        this.unmount = pipe(addDomEvent(this.node.current, \"focus\", () => this.onFocus()), addDomEvent(this.node.current, \"blur\", () => this.onBlur()));\n    }\n    unmount() { }\n}\n\nexport { FocusGesture };\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","import { extractEventInfo } from '../events/event-info.mjs';\nimport { addDomEvent } from '../events/add-dom-event.mjs';\nimport { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { noop } from '../utils/noop.mjs';\n\nfunction fireSyntheticPointerEvent(name, handler) {\n    if (!handler)\n        return;\n    const syntheticPointerEvent = new PointerEvent(\"pointer\" + name);\n    handler(syntheticPointerEvent, extractEventInfo(syntheticPointerEvent));\n}\nclass PressGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removeStartListeners = noop;\n        this.removeEndListeners = noop;\n        this.removeAccessibleListeners = noop;\n        this.startPointerPress = (startEvent, startInfo) => {\n            this.removeEndListeners();\n            if (this.isPressing)\n                return;\n            const props = this.node.getProps();\n            const endPointerPress = (endEvent, endInfo) => {\n                if (!this.checkPressEnd())\n                    return;\n                const { onTap, onTapCancel } = this.node.getProps();\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(this.node.current, endEvent.target)\n                    ? onTapCancel && onTapCancel(endEvent, endInfo)\n                    : onTap && onTap(endEvent, endInfo);\n            };\n            const removePointerUpListener = addPointerEvent(window, \"pointerup\", endPointerPress, { passive: !(props.onTap || props[\"onPointerUp\"]) });\n            const removePointerCancelListener = addPointerEvent(window, \"pointercancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo), { passive: !(props.onTapCancel || props[\"onPointerCancel\"]) });\n            this.removeEndListeners = pipe(removePointerUpListener, removePointerCancelListener);\n            this.startPress(startEvent, startInfo);\n        };\n        this.startAccessiblePress = () => {\n            const handleKeydown = (keydownEvent) => {\n                if (keydownEvent.key !== \"Enter\" || this.isPressing)\n                    return;\n                const handleKeyup = (keyupEvent) => {\n                    if (keyupEvent.key !== \"Enter\" || !this.checkPressEnd())\n                        return;\n                    fireSyntheticPointerEvent(\"up\", this.node.getProps().onTap);\n                };\n                this.removeEndListeners();\n                this.removeEndListeners = addDomEvent(this.node.current, \"keyup\", handleKeyup);\n                fireSyntheticPointerEvent(\"down\", (event, info) => {\n                    this.startPress(event, info);\n                });\n            };\n            const removeKeydownListener = addDomEvent(this.node.current, \"keydown\", handleKeydown);\n            const handleBlur = () => {\n                if (!this.isPressing)\n                    return;\n                fireSyntheticPointerEvent(\"cancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo));\n            };\n            const removeBlurListener = addDomEvent(this.node.current, \"blur\", handleBlur);\n            this.removeAccessibleListeners = pipe(removeKeydownListener, removeBlurListener);\n        };\n    }\n    startPress(event, info) {\n        this.isPressing = true;\n        const { onTapStart, whileTap } = this.node.getProps();\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        if (whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", true);\n        }\n        onTapStart && onTapStart(event, info);\n    }\n    checkPressEnd() {\n        this.removeEndListeners();\n        this.isPressing = false;\n        const props = this.node.getProps();\n        if (props.whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", false);\n        }\n        return !isDragActive();\n    }\n    cancelPress(event, info) {\n        if (!this.checkPressEnd())\n            return;\n        const { onTapCancel } = this.node.getProps();\n        onTapCancel && onTapCancel(event, info);\n    }\n    mount() {\n        const props = this.node.getProps();\n        const removePointerListener = addPointerEvent(this.node.current, \"pointerdown\", this.startPointerPress, { passive: !(props.onTapStart || props[\"onPointerStart\"]) });\n        const removeFocusListener = addDomEvent(this.node.current, \"focus\", this.startAccessiblePress);\n        this.removeStartListeners = pipe(removePointerListener, removeFocusListener);\n    }\n    unmount() {\n        this.removeStartListeners();\n        this.removeEndListeners();\n        this.removeAccessibleListeners();\n    }\n}\n\nexport { PressGesture };\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 { Feature } from '../Feature.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nclass InViewFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n    /**\n     * TODO: Remove this in 10.0\n     */\n    viewportFallback() {\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        requestAnimationFrame(() => {\n            this.hasEnteredView = true;\n            const { onViewportEnter } = this.node.getProps();\n            onViewportEnter && onViewportEnter(null);\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", true);\n            }\n        });\n    }\n    startObserver() {\n        this.unmount();\n        const { viewport = {} } = this.node.getProps();\n        const { root, margin: rootMargin, amount = \"some\", once, fallback = true, } = viewport;\n        if (typeof IntersectionObserver === \"undefined\") {\n            if (fallback)\n                this.viewportFallback();\n            return;\n        }\n        const options = {\n            root: root ? root.current : undefined,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const onIntersectionUpdate = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (this.isInView === isIntersecting)\n                return;\n            this.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 && this.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                this.hasEnteredView = true;\n            }\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const { onViewportEnter, onViewportLeave } = this.node.getProps();\n            const callback = isIntersecting ? onViewportEnter : onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(this.node.current, options, onIntersectionUpdate);\n    }\n    mount() {\n        this.startObserver();\n    }\n    update() {\n        if (typeof IntersectionObserver === \"undefined\")\n            return;\n        const { props, prevProps } = this.node;\n        const hasOptionsChanged = [\"amount\", \"margin\", \"root\"].some(hasViewportOptionChanged(props, prevProps));\n        if (hasOptionsChanged) {\n            this.startObserver();\n        }\n    }\n    unmount() { }\n}\nfunction hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {\n    return (name) => viewport[name] !== prevViewport[name];\n}\n\nexport { InViewFeature };\n","import { HoverGesture } from '../../gestures/hover.mjs';\nimport { FocusGesture } from '../../gestures/focus.mjs';\nimport { PressGesture } from '../../gestures/press.mjs';\nimport { InViewFeature } from './viewport/index.mjs';\n\nconst gestureAnimations = {\n    inView: {\n        Feature: InViewFeature,\n    },\n    tap: {\n        Feature: PressGesture,\n    },\n    focus: {\n        Feature: FocusGesture,\n    },\n    hover: {\n        Feature: HoverGesture,\n    },\n};\n\nexport { gestureAnimations };\n","import { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from '../../../utils/errors.mjs';\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 isNumOrPxType = (v) => v === number || v === px;\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        value && value.jump(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                value.jump(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 { 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 { warning, invariant } from '../utils/errors.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isRefObject } from '../utils/is-ref-object.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 { 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';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { variantProps } from './utils/variant-props.mjs';\n\nconst featureNames = Object.keys(featureDefinitions);\nconst numFeatures = featureNames.length;\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\nconst numVariantProps = variantProps.length;\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, presenceContext, 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         * Cleanup functions for active features (hover/tap/exit etc)\n         */\n        this.features = {};\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.presenceContext = presenceContext;\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, _prevProps) {\n        return {};\n    }\n    mount(instance) {\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 = this.parent.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 (process.env.NODE_ENV !== \"production\") {\n            warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n        }\n        if (this.parent)\n            this.parent.children.add(this);\n        this.update(this.props, this.presenceContext);\n    }\n    unmount() {\n        this.projection && this.projection.unmount();\n        cancelSync.update(this.notifyUpdate);\n        cancelSync.render(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        this.removeFromVariantTree && this.removeFromVariantTree();\n        this.parent && this.parent.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        for (const key in this.features) {\n            this.features[key].unmount();\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        }\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    loadFeatures({ children, ...renderedProps }, isStrict, preloadedFeatures, projectionId, initialLayoutGroupConfig) {\n        let ProjectionNodeConstructor;\n        let MeasureLayout;\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 (process.env.NODE_ENV !== \"production\" &&\n            preloadedFeatures &&\n            isStrict) {\n            const strictMessage = \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\";\n            renderedProps.ignoreStrict\n                ? warning(false, strictMessage)\n                : invariant(false, strictMessage);\n        }\n        for (let i = 0; i < numFeatures; i++) {\n            const name = featureNames[i];\n            const { isEnabled, Feature: FeatureConstructor, ProjectionNode, MeasureLayout: MeasureLayoutComponent, } = featureDefinitions[name];\n            if (ProjectionNode)\n                ProjectionNodeConstructor = ProjectionNode;\n            if (isEnabled(renderedProps)) {\n                if (!this.features[name] && FeatureConstructor) {\n                    this.features[name] = new FeatureConstructor(this);\n                }\n                if (MeasureLayoutComponent) {\n                    MeasureLayout = MeasureLayoutComponent;\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, layoutRoot, } = 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                layoutRoot,\n            });\n        }\n        return MeasureLayout;\n    }\n    updateFeatures() {\n        for (const key in this.features) {\n            const feature = this.features[key];\n            if (feature.isMounted) {\n                feature.update(this.props, this.prevProps);\n            }\n            else {\n                feature.mount();\n                feature.isMounted = true;\n            }\n        }\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    update(props, presenceContext) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.prevProps = this.props;\n        this.props = props;\n        this.prevPresenceContext = this.presenceContext;\n        this.presenceContext = presenceContext;\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.prevProps), this.prevMotionValues);\n        if (this.handleChildMotionValue) {\n            this.handleChildMotionValue();\n        }\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        return this.props.variants ? this.props.variants[name] : undefined;\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        return this.isVariantNode\n            ? this\n            : this.parent\n                ? this.parent.getClosestVariantNode()\n                : undefined;\n    }\n    getVariantContext(startAtParent = false) {\n        if (startAtParent) {\n            return this.parent ? this.parent.getVariantContext() : undefined;\n        }\n        if (!this.isControllingVariants) {\n            const context = this.parent\n                ? this.parent.getVariantContext() || {}\n                : {};\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        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            closestVariantNode.variantChildren &&\n                closestVariantNode.variantChildren.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 (value !== this.values.get(key)) {\n            this.removeValue(key);\n            this.bindToMotionValue(key, value);\n        }\n        this.values.set(key, value);\n        this.latestValues[key] = value.get();\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        this.values.delete(key);\n        const unsubscribe = this.valueSubscriptions.get(key);\n        if (unsubscribe) {\n            unsubscribe();\n            this.valueSubscriptions.delete(key);\n        }\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    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        if (this.events[eventName]) {\n            this.events[eventName].notify(...args);\n        }\n    }\n}\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 === \"9.1.7\", `Attempting to mix Framer Motion versions ${nextValue.version} with 9.1.7 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, { owner: element }));\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        return props.style ? props.style[key] : undefined;\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 { isCSSVariableName } 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';\nimport { isMotionValue } from '../../value/utils/is-motion-value.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 = (isCSSVariableName(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, prevProps) {\n        return scrapeMotionValuesFromProps(props, prevProps);\n    }\n    handleChildMotionValue() {\n        if (this.childSubscription) {\n            this.childSubscription();\n            delete this.childSubscription;\n        }\n        const { children } = this.props;\n        if (isMotionValue(children)) {\n            this.childSubscription = children.on(\"change\", (latest) => {\n                if (this.current)\n                    this.current.textContent = `${latest}`;\n            });\n        }\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        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 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, prevProps) {\n        return scrapeMotionValuesFromProps(props, prevProps);\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 { 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 { 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 { drag } from '../../motion/features/drag.mjs';\nimport { layout } from '../../motion/features/layout.mjs';\nimport { domAnimation } from './features-animation.mjs';\n\n/**\n * @public\n */\nconst domMax = {\n    ...domAnimation,\n    ...drag,\n    ...layout,\n};\n\nexport { domMax };\n"],"names":["Feature","node","_classCallCheck","this","isMounted","_createClass","key","value","isPrimaryPointer","event","pointerType","button","isPrimary","extractEventInfo","pointType","arguments","length","undefined","point","x","y","addPointerInfo","handler","secondsToMilliseconds","seconds","addDomEvent","target","eventName","options","passive","addEventListener","removeEventListener","addPointerEvent","distance","a","b","Math","abs","PanSession","handlers","_this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","xDelta","yDelta","sqrt","pow","distance2D","offset","timestamp","frameData","push","_objectSpread","_this$handlers","onStart","onMove","handlePointerMove","transformPoint","sync","handlePointerUp","end","_this$handlers2","onEnd","onSessionEnd","panInfo","type","initialInfo","onSessionStart","removeListeners","pipe","window","cancelSync","subtractPoint","_ref2","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","i","timestampedPoint","lastPoint","time","currentVelocity","Infinity","createLock","name","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal","openVertical","isDragActive","openGestureLock","calcLength","axis","max","min","isNear","maxDistance","calcAxisDelta","source","origin","originPoint","mix","scale","isNaN","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","_ref3","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createDelta","createBox","eachAxis","callback","convertBoundingBoxToBox","_ref","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","_slicedToArray","scaleKey","originKey","axisOrigin","xKeys","yKeys","transformBox","transform","measureViewportBox","instance","topLeft","bottomRight","transformBoxPoints","getBoundingClientRect","instantAnimationState","mirrorEasing","easing","p","reverseEasing","easeIn","easeOut","easeInOut","calcBezier","t","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","noop","getTForX","aX","lowerBound","upperBound","currentX","currentT","binarySubdivide","circIn","sin","acos","circOut","circInOut","backOut","backIn","backInOut","easingLookup","linear","anticipate","easingDefinitionToFunction","definition","Array","isArray","invariant","_definition","concat","isEasingArray","ease","keyframes","keyframeValues","_ref$ease","times","_ref$duration","duration","_toConsumableArray","easingFunctions","map","state","done","absoluteTimes","o","convertOffsetToTimes","defaultOffset","createInterpolator","interpolate","splice","interpolator","next","flipTarget","reverse","safeMin","minDuration","maxDuration","minDamping","maxDamping","findSpring","envelope","derivative","_ref$bounce","bounce","_ref$velocity","_ref$mass","mass","warning","dampingRatio","clamp","undampedFreq","exponentialDecay","calcAngularFreq","c","exp","d","e","f","g","initialGuess","result","rootIterations","approximateRoot","stiffness","damping","durationKeys","physicsKeys","isSpringType","keys","some","spring","restDelta","restSpeed","_objectWithoutProperties","_excluded","_getSpringOptions","springOptions","isResolvedFromDuration","derived","getSpringOptions","resolveSpring","zero","initialVelocity","createSpring","initialDelta","undampedAngularFreq","isGranularScale","angularFreq","cos","dampedAngularFreq","freqForT","sinh","cosh","current","prevT","velocityPerSecond","isBelowVelocityThreshold","isBelowDisplacementThreshold","needsInterpolation","_t","types","decay","_ref$keyframes","_ref$power","power","_ref$timeConstant","timeConstant","_ref$restDelta","modifyTarget","amplitude","ideal","tween","loopElapsed","elapsed","framesync","update","passTimestamp","start","stop","animateValue","driverControls","interpolateFromNumber","_ref2$driver","driver","_ref2$elapsed","_ref2$repeat","repeat","repeatMax","_ref2$repeatType","repeatType","_ref2$repeatDelay","repeatDelay","keyframes$1","_ref2$autoplay","autoplay","onPlay","onStop","onComplete","onRepeat","onUpdate","_ref2$type","initialElapsed","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","animation","delay","reverseElapsed","hasRepeatDelayElapsed","currentTime","sample","sampleResolution","sampleElapsed","remaining","cubicBezierAsString","supportedWaapiEasing","mapEasingToNativeEasing","featureTests","waapi","Object","hasOwnProperty","call","Element","prototype","results","supports","_loop","acceleratedValues","Set","createAcceleratedAnimation","valueName","has","_options$duration","_options$elapsed","sampleAnimation","pregeneratedKeyframes","element","_element$animate","_ref$delay","_ref$repeat","_ref$repeatType","animate","_defineProperty","fill","iterations","direction","animateStyle","owner","onfinish","set","getFinalKeyframe","cancel","setWithVelocity","timeout","performance","now","checkElapsed","createInstantAnimation","setValue","underDampedSpring","keyframesTransition","getDefaultTransition","valueKey","transformProps","startsWith","isAnimatable","complex","maxDefaults","applyDefaultFilter","v","_v$slice$split","slice","split","_v$slice$split2","match","floatRegex","number","unit","replace","defaultValue","functionRegex","filter","getAnimatableNone","functions","join","defaultValueTypes","numberValueTypes","color","backgroundColor","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","defaultValueType","isZero","parseFloat","indexOf","getZeroUnit","potentialUnitType","getValueTransition","transition","createMotionValueAnimation","valueTransition","_transition$elapsed","isTargetAnimatable","from","get","getKeyframes","originKeyframe","targetKeyframe","isOriginAnimatable","currentAnimation","_ref$bounceStiffness","bounceStiffness","_ref$bounceDamping","bounceDamping","isOutOfBounds","findNearestBoundary","startAnimation","startSpring","prev","boundary","heading","inertia","when","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","HTMLElement","getProps","acceleratedAnimation","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","_ref$snapToCursor","snapToCursor","presenceContext","isPresent","panSession","stopAnimation","_this$getProps","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","getAxisMotionValue","percent","measuredAxis","layoutBox","animationState","setActive","_this$getProps2","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","getCurrentDirection","updateAxis","render","getTransformPagePoint","onDragEnd","_this$visualElement","_point","shouldDrag","axisValue","applyConstraints","_this2","_this$getProps6","dragConstraints","prevConstraints","isRefObject","resolveRefConstraints","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","_this$getProps7","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","scroll","measurePageBox","root","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","_this3","_this$getProps8","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","startAxisValueAnimation","Promise","all","then","_this4","dragKey","toUpperCase","props","externalMotionValue","getValue","initial","_this5","_projection$layout$la","_this6","_this$getProps9","boxProgress","latest","sourceLength","targetLength","progress","calcOrigin","transformTemplate","style","updateScroll","updateLayout","_this6$constraints$ax","_this7","stopPointerListener","_this7$getProps","_this7$getProps$dragL","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","scalePositionWithinConstraints","stopLayoutUpdateListener","hasLayoutChanged","motionValue","_props$drag","_props$dragDirectionL","_props$dragPropagatio","_props$dragConstraint","_props$dragElastic","_props$dragMomentum","DragGesture","_Feature","_inherits","_super","_createSuper","removeGroupControls","controls","dragControls","subscribe","addListeners","PanGesture","apply","removePointerDownListener","pointerDownEvent","session","createPanHandlers","_this$node$getProps","onPanSessionStart","onPanStart","onPan","onPanEnd","onPointerDown","updateHandlers","pixelsToPercent","pixels","correctBorderRadius","correct","px","cssVariableRegex","maxDepth","getVariableValue","depth","_parseCSSVariable","exec","_match","parseCSSVariable","_parseCSSVariable2","token","fallback","resolved","getComputedStyle","getPropertyValue","trim","isCSSVariableToken","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","shadow","template","xScale","yScale","averageScale","output","cssVariable","MeasureLayoutWithContext","_React__default$Compo","_this$props","layoutGroup","switchLayoutGroup","layoutId","addScaleCorrector","defaultScaleCorrectors","group","add","register","didUpdate","safeToRemove","setOptions","onExitComplete","globalProjectionState","prevProps","_this$props2","layoutDependency","willUpdate","promote","relegate","stack","getStack","members","isLead","_this$props3","promoteContext","scheduleCheckAfterUnmount","remove","deregister","React__default","MeasureLayout","_usePresence","context","useContext","PresenceContext","id","useId","useEffect","usePresence","_usePresence2","LayoutGroupContext","SwitchLayoutGroupContext","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","aspectRatio","NodeStack","addUniqueItem","scheduleRender","removeItem","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","latestValues","animationValues","isUpdating","isLayoutDirty","crossfade","hide","forEach","resumingFrom","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","FlatTree","children","isDirty","child","sort","transformAxes","projectionFrameData","totalNodes","resolvedTargetDeltas","recalculatedProjection","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","ProjectionNode","elementId","animationId","isTreeAnimating","isProjectionDirty","isSharedProjectionDirty","isTransformDirty","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","Map","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","propagateDirtyNodes","resolveTargetDelta","calcProjection","cleanDirtyNodes","data","MotionDebug","record","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","SubscriptionManager","subscriptionManager","_len","args","_key","notify","SVGElement","tagName","_this$options","mount","delete","cancelDelay","resizeUnblockUpdate","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","_visualElement$getPro","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","layoutRoot","setAnimationOrigin","animationOptions","shouldReduceMotion","isUpdateBlocked","resetRotation","shouldNotifyListeners","startUpdate","_this$options2","getTransformTemplate","prevTransformTemplateValue","updateSnapshot","notifyListeners","unblockUpdate","clearMeasurements","size","mountNodeEarly","clear","resetTransformStyle","notifyLayoutUpdate","flushSync","clearSnapshot","removeLeadSnapshots","measure","alwaysMeasureLayout","prevLayout","layoutCorrected","phase","needsMeasurement","Boolean","layoutScroll","isRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","removeTransform","pageBox","removeElementScroll","roundAxis","measuredBox","boxWithoutScroll","rootScroll","transformOnly","withTransforms","boxWithoutTransform","targetDelta","scheduleUpdateProjection","_a","getLead","attemptToResolveRelativeTarget","_this$options3","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","applyTransform","isProjecting","isShared","canSkip","_this$options4","pendingAnimation","treePath","isSharedTransition","treeLength","display","applyTreeDeltas","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","prevRelativeTarget","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","to","mixAxisDelta","setTargetDelta","mixAxis","follow","opacity","opacityExit","borderLabel","followRadius","leadRadius","mixValues","isMotionValue","isAnimating","completeAnimation","exitAnimationComplete","shouldAnimatePositionOnly","animationType","xLength","yLength","config","initialPromotionConfig","shouldPreserveFollowOpacity","hasRotate","rotateZ","resetValues","setStaticValue","_b","styleProp","styles","visibility","pointerEvents","resolveMotionValue","emptyStyles","valuesToRender","applyTransformsToTarget","_this$projectionDelta","transformOrigin","scaleCorrectors","_scaleCorrectors$key","corrected","num","hasListeners","_node$layout","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","removeLeadSnapshot","searchNode","document","querySelector","round","DocumentProjectionNode","ref","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","documentNode","position","pan","shallowCompare","prevLength","isZeroValueString","test","testValueType","dimensionValueTypes","degrees","vw","vh","parse","findDimensionValueType","find","valueTypes","findValueType","resolveVariant","custom","resolveVariantFromProps","getCurrent","setMotionValue","hasValue","addValue","setTarget","makeTargetAnimatable","_ref$transitionEnd","transitionEnd","resolveFinalValueInKeyframes","getOriginFromTransition","isWillChangeMotionValue","optimizedAppearDataAttribute","camelToDash","animateVariant","variant","_ref$transition","transitionOverride","getAnimation","animateTarget","resolve","getChildAnimations","variantChildren","forwardDelay","_transition","_transition$delayChil","animations","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","animateChildren","first","last","_ref4","_ref4$delay","_visualElement$makeTa","_visualElement$makeTa2","willChange","animationTypeState","getState","valueTarget","_ref5","protectedKeys","needsAnimating","shouldBlock","shouldBlockAnimation","HandoffAppearAnimations","hasAnimated","appearId","sortNodePosition","reversePriorityOrder","variantPriorityOrder","numAnimationTypes","animateList","resolvedDefinition","animateVisualElement","createAnimationState","createTypeState","whileInView","whileHover","whileTap","whileDrag","whileFocus","exit","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","_typeState$prevResolv","prevResolvedValues","allKeys","markToAnimate","isKeyframesTarget","blockInitialAnimation","fallbackAnimation","fallbackTarget","getBaseTarget","shouldAnimate","setAnimateFunction","makeAnimator","AnimationFeature","unmount","updateAnimationControlsSubscription","ExitAnimationFeature","_this$node$presenceCo","prevIsPresent","prevPresenceContext","exitAnimation","addHoverEvent","callbackName","HoverGesture","FocusGesture","isFocusVisible","matches","onFocus","onBlur","isNodeOrChild","parentElement","fireSyntheticPointerEvent","syntheticPointerEvent","PointerEvent","PressGesture","removeStartListeners","removeEndListeners","removeAccessibleListeners","startPointerPress","startInfo","isPressing","removePointerUpListener","endEvent","endInfo","checkPressEnd","onTap","onTapCancel","removePointerCancelListener","cancelEvent","cancelInfo","cancelPress","startPress","startAccessiblePress","removeKeydownListener","keydownEvent","keyupEvent","removeBlurListener","_this$node$getProps2","onTapStart","removePointerListener","removeFocusListener","observerCallbacks","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","lookupRoot","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","thresholdNames","InViewFeature","hasEnteredView","isInView","requestAnimationFrame","onViewportEnter","_this$node$getProps$v","viewport","rootMargin","margin","_viewport$amount","amount","once","_viewport$fallback","threshold","isIntersecting","_this3$node$getProps","onViewportLeave","viewportFallback","startObserver","_this$node","hasOptionsChanged","_ref$viewport","_ref2$viewport","prevViewport","hasViewportOptionChanged","gestureAnimations","inView","tap","focus","hover","positionalKeys","isPositionalKey","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","transformPropOrder","positionalValues","width","_ref3$paddingLeft","paddingLeft","_ref3$paddingRight","paddingRight","height","_ref5$paddingTop","paddingTop","_ref5$paddingBottom","paddingBottom","_ref6","_ref7","_ref8","_ref9","_ref10","_ref11","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","jump","scrollY","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","targetBbox","convertChangedValueTypes","_ref12","_ref13","isBrowser","scrollTo","unitConversion","hasPositionalKey","parseDomVariant","assign","_objectDestructuringEmpty","resolveCSSVariables","prefersReducedMotion","hasReducedMotionListener","featureNames","featureDefinitions","numFeatures","propEventHandlers","numVariantProps","variantProps","VisualElement","reducedMotionConfig","visualState","isVariantNode","isControllingVariants","features","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","triggerBuild","renderInstance","renderState","baseTarget","initialValues","_this$scrapeMotionVal","scrapeMotionValuesFromProps","initialMotionValues","_props","_prevProps","removeFromVariantTree","addVariantChild","bindToMotionValue","matchMedia","motionMediaQuery","setReducedMotionPreferences","addListener","initPrefersReducedMotion","valueIsTransform","removeOnChange","on","latestValue","removeOnRenderRequest","other","sortInstanceNodePosition","isStrict","preloadedFeatures","projectionId","initialLayoutGroupConfig","ProjectionNodeConstructor","renderedProps","_excluded2","_featureDefinitions$n","isEnabled","FeatureConstructor","MeasureLayoutComponent","feature","build","measureInstanceViewportBox","canMutate","makeTargetAnimatableFromInstance","listener","nextValue","prevValue","existingValue","getStaticValue","removeValue","updateMotionValuesFromProps","handleChildMotionValue","variants","getClosestVariantNode","closestVariantNode","unsubscribe","removeValueFromRenderState","readValueFromInstance","valueFromInitial","getBaseTargetFromProps","_this$events$eventNam","_key2","DOMVisualElement","_VisualElement","compareDocumentPosition","vars","transformValues","transitionOrigin","getOrigin","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","checkTargetForNewValues","parsed","HTMLVisualElement","_DOMVisualElement","defaultType","default","computedStyle","isCSSVariableName","buildHTMLStyles","childSubscription","textContent","renderHTML","SVGVisualElement","isSVGTag","camelCaseAttributes","getAttribute","buildSVGAttrs","renderSVG","_get","_getPrototypeOf","domAnimation","renderer","Component","isSVGComponent","enableHardwareAcceleration","domMax"],"sourceRoot":""}