{"version":3,"file":"static/js/1773.72db6d93.chunk.js","mappings":"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","sources":["../node_modules/hey-listen/dist/hey-listen.es.js","../node_modules/popmotion/dist/es/easing/cubic-bezier.mjs","../node_modules/framer-motion/dist/es/animation/utils/easing.mjs","../node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","../node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","../node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","../node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","../node_modules/popmotion/dist/es/animations/inertia.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","../node_modules/framer-motion/dist/es/events/event-info.mjs","../node_modules/framer-motion/dist/es/events/use-dom-event.mjs","../node_modules/framer-motion/dist/es/events/use-pointer-event.mjs","../node_modules/framer-motion/dist/es/events/utils.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","../node_modules/framer-motion/dist/es/gestures/utils/event-type.mjs","../node_modules/framer-motion/dist/es/motion/features/animations.mjs","../node_modules/framer-motion/dist/es/gestures/PanSession.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","../node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","../node_modules/framer-motion/dist/es/motion/features/drag.mjs","../node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","../node_modules/framer-motion/dist/es/gestures/use-hover-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/use-viewport.mjs","../node_modules/framer-motion/dist/es/motion/features/gestures.mjs","../node_modules/framer-motion/dist/es/gestures/use-tap-gesture.mjs","../node_modules/framer-motion/dist/es/gestures/use-focus-gesture.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","../node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","../node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","../node_modules/framer-motion/dist/es/motion/utils/make-renderless-component.mjs","../node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","../node_modules/framer-motion/dist/es/projection/geometry/models.mjs","../node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","../node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","../node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","../node_modules/framer-motion/dist/es/projection/shared/stack.mjs","../node_modules/framer-motion/dist/es/projection/styles/transform.mjs","../node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","../node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","../node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","../node_modules/framer-motion/dist/es/animation/animate.mjs","../node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","../node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","../node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","../node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","../node_modules/framer-motion/dist/es/projection/utils/measure.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","../node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","../node_modules/framer-motion/dist/es/render/VisualElement.mjs","../node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","../node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","../node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","../node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","../node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/defaults.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/test.mjs","../node_modules/framer-motion/dist/es/utils/shallow-compare.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/render/utils/resolve-dynamic-variants.mjs","../node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","../node_modules/framer-motion/dist/es/render/utils/setters.mjs","../node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","../node_modules/framer-motion/dist/es/render/utils/types.mjs","../node_modules/framer-motion/dist/es/utils/delay.mjs","../node_modules/framer-motion/dist/es/utils/time-conversion.mjs","../node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","../node_modules/popmotion/node_modules/tslib/tslib.es6.js","../node_modules/popmotion/dist/es/animations/utils/find-spring.mjs","../node_modules/popmotion/dist/es/animations/generators/spring.mjs","../node_modules/popmotion/dist/es/animations/generators/keyframes.mjs","../node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.mjs","../node_modules/popmotion/dist/es/animations/generators/decay.mjs","../node_modules/popmotion/dist/es/animations/utils/elapsed.mjs","../node_modules/popmotion/dist/es/animations/index.mjs","../node_modules/popmotion/dist/es/easing/utils.mjs","../node_modules/popmotion/dist/es/easing/index.mjs","../node_modules/popmotion/dist/es/utils/clamp.mjs","../node_modules/popmotion/dist/es/utils/is-point.mjs","../node_modules/popmotion/dist/es/utils/is-point-3d.mjs","../node_modules/popmotion/dist/es/utils/distance.mjs","../node_modules/popmotion/dist/es/utils/inc.mjs","../node_modules/popmotion/dist/es/utils/hsla-to-rgba.mjs","../node_modules/popmotion/dist/es/utils/mix-color.mjs","../node_modules/popmotion/dist/es/utils/mix-complex.mjs","../node_modules/popmotion/dist/es/utils/interpolate.mjs","../node_modules/popmotion/dist/es/utils/mix.mjs","../node_modules/popmotion/dist/es/utils/pipe.mjs","../node_modules/popmotion/dist/es/utils/progress.mjs","../node_modules/style-value-types/dist/es/color/hex.mjs","../node_modules/style-value-types/dist/es/color/hsla.mjs","../node_modules/style-value-types/dist/es/color/index.mjs","../node_modules/style-value-types/dist/es/color/rgba.mjs","../node_modules/style-value-types/dist/es/color/utils.mjs","../node_modules/style-value-types/dist/es/complex/filter.mjs","../node_modules/style-value-types/dist/es/complex/index.mjs"],"sourcesContent":["var warning = function () { };\r\nvar invariant = function () { };\r\nif (process.env.NODE_ENV !== 'production') {\r\n    warning = function (check, message) {\r\n        if (!check && typeof console !== 'undefined') {\r\n            console.warn(message);\r\n        }\r\n    };\r\n    invariant = function (check, message) {\r\n        if (!check) {\r\n            throw new Error(message);\r\n        }\r\n    };\r\n}\n\nexport { invariant, warning };\n","import { linear } from './index.mjs';\n\nconst a = (a1, a2) => 1.0 - 3.0 * a2 + 3.0 * a1;\nconst b = (a1, a2) => 3.0 * a2 - 6.0 * a1;\nconst c = (a1) => 3.0 * a1;\nconst calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\nconst getSlope = (t, a1, a2) => 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 10;\nfunction binarySubdivide(aX, aA, aB, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = aA + (aB - aA) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - aX;\n        if (currentX > 0.0) {\n            aB = currentT;\n        }\n        else {\n            aA = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nconst newtonIterations = 8;\nconst newtonMinSlope = 0.001;\nfunction newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {\n    for (let i = 0; i < newtonIterations; ++i) {\n        const currentSlope = getSlope(aGuessT, mX1, mX2);\n        if (currentSlope === 0.0) {\n            return aGuessT;\n        }\n        const currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n        aGuessT -= currentX / currentSlope;\n    }\n    return aGuessT;\n}\nconst kSplineTableSize = 11;\nconst kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    if (mX1 === mY1 && mX2 === mY2)\n        return linear;\n    const sampleValues = new Float32Array(kSplineTableSize);\n    for (let i = 0; i < kSplineTableSize; ++i) {\n        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n    }\n    function getTForX(aX) {\n        let intervalStart = 0.0;\n        let currentSample = 1;\n        const lastSample = kSplineTableSize - 1;\n        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += kSampleStepSize;\n        }\n        --currentSample;\n        const dist = (aX - sampleValues[currentSample]) /\n            (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n        const guessForT = intervalStart + dist * kSampleStepSize;\n        const initialSlope = getSlope(guessForT, mX1, mX2);\n        if (initialSlope >= newtonMinSlope) {\n            return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n        }\n        else if (initialSlope === 0.0) {\n            return guessForT;\n        }\n        else {\n            return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n        }\n    }\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { invariant } from 'hey-listen';\nimport { cubicBezier, linear, easeIn, easeInOut, easeOut, circIn, circInOut, circOut, backIn, backInOut, backOut, anticipate, bounceIn, bounceInOut, bounceOut } from 'popmotion';\n\nconst easingLookup = {\n    linear,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n    bounceIn,\n    bounceInOut,\n    bounceOut,\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 { complex } from 'style-value-types';\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 { isKeyframesTarget } from './is-keyframes-target.mjs';\n\nconst underDampedSpring = () => ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n});\nconst criticallyDampedSpring = (to) => ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n});\nconst linearTween = () => ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n});\nconst keyframes = (values) => ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values,\n});\nconst defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nconst getDefaultTransition = (valueKey, to) => {\n    let transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return { to, ...transitionFactory(to) };\n};\n\nexport { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };\n","const instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","import { inertia, animate } from 'popmotion';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { isEasingArray, easingDefinitionToFunction } from './easing.mjs';\nimport { isAnimatable } from './is-animatable.mjs';\nimport { getDefaultTransition } from './default-transitions.mjs';\nimport { warning } from 'hey-listen';\nimport { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { delay } from '../../utils/delay.mjs';\n\n/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, ...transition }) {\n    return !!Object.keys(transition).length;\n}\nlet legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions({ ease, times, yoyo, flip, loop, ...transition }) {\n    const options = { ...transition };\n    if (times)\n        options[\"offset\"] = times;\n    /**\n     * Convert any existing durations from seconds to milliseconds\n     */\n    if (transition.duration)\n        options[\"duration\"] = secondsToMilliseconds(transition.duration);\n    if (transition.repeatDelay)\n        options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n    /**\n     * Map easing names to Popmotion's easing functions\n     */\n    if (ease) {\n        options[\"ease\"] = isEasingArray(ease)\n            ? ease.map(easingDefinitionToFunction)\n            : easingDefinitionToFunction(ease);\n    }\n    /**\n     * Support legacy transition API\n     */\n    if (transition.type === \"tween\")\n        options.type = \"keyframes\";\n    /**\n     * TODO: These options are officially removed from the API.\n     */\n    if (yoyo || loop || flip) {\n        warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n        legacyRepeatWarning = true;\n        if (yoyo) {\n            options.repeatType = \"reverse\";\n        }\n        else if (loop) {\n            options.repeatType = \"loop\";\n        }\n        else if (flip) {\n            options.repeatType = \"mirror\";\n        }\n        options.repeat = loop || yoyo || flip || transition.repeat;\n    }\n    /**\n     * TODO: Popmotion 9 has the ability to automatically detect whether to use\n     * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n     * It'd be good to introduce a similar thing here.\n     */\n    if (transition.type !== \"spring\")\n        options.type = \"keyframes\";\n    return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n    var _a, _b;\n    const valueTransition = getValueTransition(transition, key) || {};\n    return (_b = (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : transition.delay) !== null && _b !== void 0 ? _b : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = [...options.to];\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    if (Array.isArray(options.to) && transition.duration === undefined) {\n        transition.duration = 0.8;\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = {\n            ...transition,\n            ...getDefaultTransition(key, options.to),\n        };\n    }\n    return {\n        ...options,\n        ...convertTransitionToAnimationOptions(transition),\n    };\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n    const valueTransition = getValueTransition(transition, key) || {};\n    let origin = valueTransition.from !== undefined ? valueTransition.from : value.get();\n    const isTargetAnimatable = isAnimatable(key, target);\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(key, 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    const isOriginAnimatable = isAnimatable(key, origin);\n    warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${key} from \"${origin}\" to \"${target}\". ${origin} is not an animatable value - to enable this animation set ${origin} to a value animatable to ${target} via the \\`style\\` property.`);\n    function start() {\n        const options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete,\n            onUpdate: (v) => value.set(v),\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? inertia({ ...options, ...valueTransition })\n            : animate({\n                ...getPopmotionAnimationOptions(valueTransition, options, key),\n                onUpdate: (v) => {\n                    options.onUpdate(v);\n                    valueTransition.onUpdate && valueTransition.onUpdate(v);\n                },\n                onComplete: () => {\n                    options.onComplete();\n                    valueTransition.onComplete && valueTransition.onComplete();\n                },\n            });\n    }\n    function set() {\n        const finalTarget = resolveFinalValueInKeyframes(target);\n        value.set(finalTarget);\n        onComplete();\n        valueTransition.onUpdate && valueTransition.onUpdate(finalTarget);\n        valueTransition.onComplete && valueTransition.onComplete();\n        return { stop: () => { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\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/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n */\nfunction startAnimation(key, value, target, transition = {}) {\n    if (instantAnimationState.current) {\n        transition = { type: false };\n    }\n    return value.start((onComplete) => {\n        let controls;\n        const animation = getAnimation(key, value, target, transition, onComplete);\n        const delayBy = getDelayFromTransition(transition, key);\n        const start = () => (controls = animation());\n        let cancelDelay;\n        if (delayBy) {\n            cancelDelay = delay(start, secondsToMilliseconds(delayBy));\n        }\n        else {\n            start();\n        }\n        return () => {\n            cancelDelay && cancelDelay();\n            controls && controls.stop();\n        };\n    });\n}\n\nexport { convertTransitionToAnimationOptions, getDelayFromTransition, getPopmotionAnimationOptions, getValueTransition, getZeroUnit, hydrateKeyframes, isTransitionDefined, isZero, startAnimation };\n","import { animate } from './index.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { getFrameData } from 'framesync';\n\nfunction inertia({ from = 0, velocity = 0, min, max, power = 0.8, timeConstant = 750, bounceStiffness = 500, bounceDamping = 10, restDelta = 1, modifyTarget, driver, onUpdate, onComplete, onStop, }) {\n    let currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function boundaryNearest(v) {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    }\n    function startAnimation(options) {\n        currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n        currentAnimation = animate(Object.assign(Object.assign({}, options), { driver, onUpdate: (v) => {\n                var _a;\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n                (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n            }, onComplete,\n            onStop }));\n    }\n    function startSpring(options) {\n        startAnimation(Object.assign({ type: \"spring\", stiffness: bounceStiffness, damping: bounceDamping, restDelta }, options));\n    }\n    if (isOutOfBounds(from)) {\n        startSpring({ from, velocity, to: boundaryNearest(from) });\n    }\n    else {\n        let target = power * velocity + from;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        const boundary = boundaryNearest(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, getFrameData().delta);\n            if ((heading === 1 && v > boundary) ||\n                (heading === -1 && v < boundary)) {\n                startSpring({ from: v, to: boundary, velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            from,\n            velocity,\n            timeConstant,\n            power,\n            restDelta,\n            modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: () => currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop(),\n    };\n}\n\nexport { inertia };\n","import { useContext, useId, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    const context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    const { isPresent, onExitComplete, register } = context;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    // Replace with useId when released in React\n    const id = useId();\n    useEffect(() => register(id), []);\n    const safeToRemove = () => onExitComplete && onExitComplete(id);\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","import { isTouchEvent } from '../gestures/utils/event-type.mjs';\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return (event) => {\n        const isMouseEvent = event instanceof MouseEvent;\n        const isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nconst defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType = \"page\") {\n    const primaryTouch = e.touches[0] || e.changedTouches[0];\n    const point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType = \"page\") {\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType = \"page\") {\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nconst wrapHandler = (handler, shouldFilterPrimaryPointer = false) => {\n    const listener = (event) => handler(event, extractEventInfo(event));\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\nexport { extractEventInfo, wrapHandler };\n","import { useEffect } from 'react';\n\nfunction addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    useEffect(() => {\n        const element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\nexport { addDomEvent, useDomEvent };\n","import { addDomEvent, useDomEvent } from './use-dom-event.mjs';\nimport { wrapHandler } from './event-info.mjs';\nimport { supportsPointerEvents, supportsTouchEvents, supportsMouseEvents } from './utils.mjs';\n\nconst mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nconst touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nexport { addPointerEvent, usePointerEvent };\n","import { isBrowser } from '../utils/is-browser.mjs';\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nconst supportsPointerEvents = () => isBrowser && window.onpointerdown === null;\nconst supportsTouchEvents = () => isBrowser && window.ontouchstart === null;\nconst supportsMouseEvents = () => isBrowser && window.onmousedown === null;\n\nexport { supportsMouseEvents, supportsPointerEvents, supportsTouchEvents };\n","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","function isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    const hasTouches = !!event.touches;\n    return hasTouches;\n}\n\nexport { isMouseEvent, isTouchEvent };\n","import { useEffect, useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { usePresence } from '../../components/AnimatePresence/use-presence.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { createAnimationState } from '../../render/utils/animation-state.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nconst animations = {\n    animation: makeRenderlessComponent(({ visualElement, animate }) => {\n        /**\n         * We dynamically generate the AnimationState manager as it contains a reference\n         * to the underlying animation library. We only want to load that if we load this,\n         * so people can optionally code split it out using the `m` component.\n         */\n        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            useEffect(() => animate.subscribe(visualElement), [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent((props) => {\n        const { custom, visualElement } = props;\n        const [isPresent, safeToRemove] = usePresence();\n        const presenceContext = useContext(PresenceContext);\n        useEffect(() => {\n            visualElement.isPresent = isPresent;\n            const animation = visualElement.animationState &&\n                visualElement.animationState.setActive(AnimationType.Exit, !isPresent, {\n                    custom: (presenceContext && presenceContext.custom) ||\n                        custom,\n                });\n            if (animation && !isPresent) {\n                animation.then(safeToRemove);\n            }\n        }, [isPresent]);\n    }),\n};\n\nexport { animations };\n","import { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { distance, pipe } from 'popmotion';\n\n/**\n * @internal\n */\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 = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            const { point } = info;\n            const { timestamp } = getFrameData();\n            this.history.push({ ...point, timestamp });\n            const { onStart, onMove } = this.handlers;\n            if (!isPanStarted) {\n                onStart && onStart(this.lastMoveEvent, info);\n                this.startEvent = this.lastMoveEvent;\n            }\n            onMove && onMove(this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = (event, info) => {\n            this.lastMoveEvent = event;\n            this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync.update(this.updatePoint, true);\n        };\n        this.handlePointerUp = (event, info) => {\n            this.end();\n            const { onEnd, onSessionEnd } = this.handlers;\n            const panInfo = getPanInfo(transformPoint(info, this.transformPagePoint), this.history);\n            if (this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        const info = extractEventInfo(event);\n        const initialInfo = transformPoint(info, this.transformPagePoint);\n        const { point } = initialInfo;\n        const { timestamp } = getFrameData();\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","import { mix, progress, clamp } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, { 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    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","import { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\n\nconst elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nclass VisualElementDragControls {\n    constructor(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    start(originEvent, { snapToCursor = false } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        const onSessionStart = (event) => {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            this.stopAnimation();\n            if (snapToCursor) {\n                this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        const onStart = (event, info) => {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\n            if (drag && !dragPropagation) {\n                if (this.openGlobalLock)\n                    this.openGlobalLock();\n                this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!this.openGlobalLock)\n                    return;\n            }\n            this.isDragging = true;\n            this.currentDirection = null;\n            this.resolveConstraints();\n            if (this.visualElement.projection) {\n                this.visualElement.projection.isAnimationBlocked = true;\n                this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis((axis) => {\n                var _a, _b;\n                let current = this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    const measuredAxis = (_b = (_a = this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.layoutBox[axis];\n                    if (measuredAxis) {\n                        const length = calcLength(measuredAxis);\n                        current = length * (parseFloat(current) / 100);\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Drag, true);\n        };\n        const onMove = (event, info) => {\n            // latestPointerEvent = event\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openGlobalLock)\n                return;\n            const { offset } = info;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && this.currentDirection === null) {\n                this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            this.updateAxis(\"x\", info.point, offset);\n            this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            this.visualElement.render();\n            /**\n             * This must fire after the render call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        const onSessionEnd = (event, info) => this.stop(event, info);\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    }\n    stop(event, info) {\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        const { velocity } = info;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    }\n    cancel() {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(AnimationType.Drag, false);\n    }\n    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    }\n    resolveConstraints() {\n        const { dragConstraints, dragElastic } = this.getProps();\n        const { layout } = this.visualElement.projection || {};\n        const prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.layoutBox, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis((axis) => {\n                if (this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        const constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            var _a;\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            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 startAnimation(axis, axisValue, 0, transition);\n    }\n    stopAnimation() {\n        eachAxis((axis) => this.getAxisMotionValue(axis).stop());\n    }\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    getAxisMotionValue(axis) {\n        var _a, _b;\n        const dragKey = \"_drag\" + axis.toUpperCase();\n        const externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\n                axisValue.set(point[axis] - mix(min, max, 0.5));\n            }\n        });\n    }\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    scalePositionWithinConstraints() {\n        var _a;\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue) {\n                const latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    }\n    addListeners() {\n        var _a;\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            drag && dragListener && this.start(event);\n        });\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (isRefObject(dragConstraints)) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        };\n        const { projection } = this.visualElement;\n        const stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const motionValue = this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                this.visualElement.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener === null || stopLayoutUpdateListener === void 0 ? void 0 : stopLayoutUpdateListener();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\n}\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold = 10) {\n    let direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\n","import { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nconst drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture({ onPan, onPanStart, onPanEnd, onPanSessionStart, visualElement, }) {\n    const hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    const panSession = useRef(null);\n    const { transformPagePoint } = useContext(MotionConfigContext);\n    const handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: (event, info) => {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    useEffect(() => {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(() => panSession.current && panSession.current.end());\n}\n\nexport { usePanGesture };\n","import { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    const { dragControls: groupDragControls, visualElement } = props;\n    const dragControls = useConstant(() => new VisualElementDragControls(visualElement));\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    useEffect(() => groupDragControls && groupDragControls.subscribe(dragControls), [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(() => dragControls.addListeners(), [dragControls]);\n}\n\nexport { useDrag };\n","import { isMouseEvent } from './utils/event-type.mjs';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return (event, info) => {\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        if (visualElement.animationState) {\n            visualElement.animationState.setActive(AnimationType.Hover, isActive);\n        }\n        callback && callback(event, info);\n    };\n}\nfunction useHoverGesture({ onHoverStart, onHoverEnd, whileHover, visualElement, }) {\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\n}\n\nexport { useHoverGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nconst isNodeOrChild = (parent, child) => {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nconst observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nconst observers = new WeakMap();\nconst fireObserverCallback = (entry) => {\n    const callback = observerCallbacks.get(entry.target);\n    callback && callback(entry);\n};\nconst fireAllObserverCallbacks = (entries) => {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver({ root, ...options }) {\n    const lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    const rootObservers = observers.get(lookupRoot);\n    const key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    const rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return () => {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { env } from '../../../utils/process.mjs';\nimport { useRef, useEffect } from 'react';\nimport { AnimationType } from '../../../render/utils/types.mjs';\nimport { warnOnce } from '../../../utils/warn-once.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nfunction useViewport({ visualElement, whileInView, onViewportEnter, onViewportLeave, viewport = {}, }) {\n    const state = useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    let shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    const useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, { root, margin: rootMargin, amount = \"some\", once }) {\n    useEffect(() => {\n        if (!shouldObserve || !visualElement.current)\n            return;\n        const options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const intersectionCallback = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            if (visualElement.animationState) {\n                visualElement.animationState.setActive(AnimationType.InView, isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const props = visualElement.getProps();\n            const callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(visualElement.current, options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, { fallback = true }) {\n    useEffect(() => {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(() => {\n            state.hasEnteredView = true;\n            const { onViewportEnter } = visualElement.getProps();\n            onViewportEnter && onViewportEnter(null);\n            if (visualElement.animationState) {\n                visualElement.animationState.setActive(AnimationType.InView, true);\n            }\n        });\n    }, [shouldObserve]);\n}\n\nexport { useViewport };\n","import { useFocusGesture } from '../../gestures/use-focus-gesture.mjs';\nimport { useHoverGesture } from '../../gestures/use-hover-gesture.mjs';\nimport { useTapGesture } from '../../gestures/use-tap-gesture.mjs';\nimport { useViewport } from './viewport/use-viewport.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nconst gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nexport { gestureAnimations };\n","import { useRef } from 'react';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { usePointerEvent, addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { pipe } from 'popmotion';\nimport { AnimationType } from '../render/utils/types.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture({ onTap, onTapStart, onTapCancel, whileTap, visualElement, }) {\n    const hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    const isPressing = useRef(false);\n    const cancelPointerEndListeners = useRef(null);\n    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    const eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        cancelPointerEndListeners.current && cancelPointerEndListeners.current();\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        removePointerEndListener();\n        isPressing.current = false;\n        visualElement.animationState &&\n            visualElement.animationState.setActive(AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.current, event.target)\n            ? onTapCancel && onTapCancel(event, info)\n            : onTap && onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel && onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = pipe(addPointerEvent(window, \"pointerup\", onPointerUp, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        visualElement.animationState &&\n            visualElement.animationState.setActive(AnimationType.Tap, true);\n        onTapStart && onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nexport { useTapGesture };\n","import { AnimationType } from '../render/utils/types.mjs';\nimport { useDomEvent } from '../events/use-dom-event.mjs';\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture({ whileFocus, visualElement, }) {\n    const { animationState } = visualElement;\n    const onFocus = () => {\n        animationState && animationState.setActive(AnimationType.Focus, true);\n    };\n    const onBlur = () => {\n        animationState && animationState.setActive(AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nexport { useFocusGesture };\n","import { px } from 'style-value-types';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\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 { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.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 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nclass MeasureLayoutWithContext extends React__default.Component {\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    componentDidMount() {\n        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;\n        const { projection } = visualElement;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", () => {\n                this.safeToRemove();\n            });\n            projection.setOptions({\n                ...projection.options,\n                onExitComplete: () => this.safeToRemove(),\n            });\n        }\n        globalProjectionState.hasEverUpdated = true;\n    }\n    getSnapshotBeforeUpdate(prevProps) {\n        const { layoutDependency, visualElement, drag, isPresent } = this.props;\n        const projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync.postRender(() => {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    }\n    componentDidUpdate() {\n        const { projection } = this.props.visualElement;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    }\n    componentWillUnmount() {\n        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;\n        const { projection } = visualElement;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    }\n    safeToRemove() {\n        const { safeToRemove } = this.props;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    }\n    render() {\n        return null;\n    }\n}\nfunction MeasureLayout(props) {\n    const [isPresent, safeToRemove] = usePresence();\n    const layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));\n}\nconst defaultScaleCorrectors = {\n    borderRadius: {\n        ...correctBorderRadius,\n        applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ],\n    },\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nconst layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\n","const makeRenderlessComponent = (hook) => (props) => {\n    hook(props);\n    return null;\n};\n\nexport { makeRenderlessComponent };\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","import { mix } from 'popmotion';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    const distanceFromOrigin = point - originPoint;\n    const scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, { x, y }) {\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {\n    var _a, _b;\n    const treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    let node;\n    let delta;\n    for (let i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, {\n                x: -node.scroll.offset.x,\n                y: -node.scroll.offset.y,\n            });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n}\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 { mix, distance } from 'popmotion';\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target = 0, maxDistance = 0.01) {\n    return distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin = 0.5) {\n    delta.origin = origin;\n    delta.originPoint = mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","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","import { mix, progress, circOut, linear } from 'popmotion';\nimport { percent, px } from 'style-value-types';\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    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 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    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : 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, linear);\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 'popmotion';\nimport { percent } from 'style-value-types';\nimport { scalePoint } from './delta-apply.mjs';\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        const relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    let originPoint = mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","import { distance } from 'popmotion';\nimport { 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}\nfunction isCloseTo(a, b, max = 0.1) {\n    return distance(a, b) <= max;\n}\n\nexport { aspectRatio, boxEquals, isCloseTo, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nclass NodeStack {\n    constructor() {\n        this.members = [];\n    }\n    add(node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    }\n    remove(node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            const prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    }\n    relegate(node) {\n        const indexOfNode = this.members.findIndex((member) => node === member);\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        let prevLead;\n        for (let i = indexOfNode; i >= 0; i--) {\n            const member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    promote(node, preserveFollowOpacity) {\n        var _a;\n        const prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            const { crossfade } = node.options;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    }\n    exitAnimationComplete() {\n        this.members.forEach((node) => {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    }\n    scheduleRender() {\n        this.members.forEach((node) => {\n            node.instance && node.scheduleRender(false);\n        });\n    }\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    removeLeadSnapshot() {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    }\n}\n\nexport { NodeStack };\n","function buildProjectionTransform(delta, treeScale, latestTransform) {\n    let transform = \"\";\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    const xTranslate = delta.x.translate / treeScale.x;\n    const yTranslate = delta.y.translate / treeScale.y;\n    if (xTranslate || yTranslate) {\n        transform = `translate3d(${xTranslate}px, ${yTranslate}px, 0) `;\n    }\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    if (treeScale.x !== 1 || treeScale.y !== 1) {\n        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;\n    }\n    if (latestTransform) {\n        const { rotate, rotateX, rotateY } = latestTransform;\n        if (rotate)\n            transform += `rotate(${rotate}deg) `;\n        if (rotateX)\n            transform += `rotateX(${rotateX}deg) `;\n        if (rotateY)\n            transform += `rotateY(${rotateY}deg) `;\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    const elementScaleX = delta.x.scale * treeScale.x;\n    const elementScaleY = delta.y.scale * treeScale.y;\n    if (elementScaleX !== 1 || elementScaleY !== 1) {\n        transform += `scale(${elementScaleX}, ${elementScaleY})`;\n    }\n    return transform || \"none\";\n}\n\nexport { buildProjectionTransform };\n","const compareByDepth = (a, b) => a.depth - b.depth;\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nclass FlatTree {\n    constructor() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    add(child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    }\n    remove(child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    }\n    forEach(callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    }\n}\n\nexport { FlatTree };\n","import sync, { cancelSync, flushSync } from 'framesync';\nimport { mix } from 'popmotion';\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 } 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, isCloseTo, 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';\n\nconst transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nconst animationTarget = 1000;\nlet id = 0;\nfunction createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform, }) {\n    return class ProjectionNode {\n        constructor(elementId, latestValues = {}, parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent()) {\n            /**\n             * A unique ID generated for every projection node.\n             */\n            this.id = id++;\n            /**\n             * An id that represents a unique session instigated by startUpdate.\n             */\n            this.animationId = 0;\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            this.isTransformDirty = false;\n            /**\n             * Flag to true if we think the projection calculations for this or any\n             * child might need recalculating as a result of an updated transform or layout animation.\n             */\n            this.isProjectionDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to layoutly\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = () => {\n                if (this.isUpdating) {\n                    this.isUpdating = false;\n                    this.clearAllSnapshots();\n                }\n            };\n            /**\n             * This is a multi-step process as shared nodes might be of different depths. Nodes\n             * are sorted by depth order, so we need to resolve the entire tree before moving to\n             * the next step.\n             */\n            this.updateProjection = () => {\n                this.nodes.forEach(propagateDirtyNodes);\n                this.nodes.forEach(resolveTargetDelta);\n                this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.elementId = elementId;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? [...parent.path, parent] : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            elementId && this.root.registerPotentialNode(elementId, this);\n            for (let i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        addEventListener(name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        }\n        notifyListeners(name, ...args) {\n            const subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify(...args);\n        }\n        hasListeners(name) {\n            return this.eventHandlers.has(name);\n        }\n        registerPotentialNode(elementId, node) {\n            this.potentialNodes.set(elementId, node);\n        }\n        /**\n         * Lifecycles\n         */\n        mount(instance, isLayoutDirty = false) {\n            var _a;\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            const { layoutId, layout, visualElement } = this.options;\n            if (visualElement && !visualElement.current) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.elementId && this.root.potentialNodes.delete(this.elementId);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                let cancelDelay;\n                const resizeUnblockUpdate = () => (this.root.updateBlockedByResize = false);\n                attachResizeListener(instance, () => {\n                    this.root.updateBlockedByResize = true;\n                    cancelDelay && cancelDelay();\n                    cancelDelay = delay(resizeUnblockUpdate, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", ({ delta, hasLayoutChanged, hasRelativeTargetChanged, layout: newLayout, }) => {\n                    var _a, _b, _c, _d, _e;\n                    if (this.isTreeAnimationBlocked()) {\n                        this.target = undefined;\n                        this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    const layoutTransition = (_b = (_a = this.options.transition) !== null && _a !== void 0 ? _a : visualElement.getDefaultTransition()) !== null && _b !== void 0 ? _b : defaultLayoutTransition;\n                    const { onLayoutAnimationStart, onLayoutAnimationComplete, } = visualElement.getProps();\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    const targetChanged = !this.targetLayout ||\n                        !boxEquals(this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_c = this.resumeFrom) === null || _c === void 0 ? void 0 : _c.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !this.currentAnimation))) {\n                        if (this.resumeFrom) {\n                            this.resumingFrom = this.resumeFrom;\n                            this.resumingFrom.resumingFrom = undefined;\n                        }\n                        this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        const animationOptions = {\n                            ...getValueTransition(layoutTransition, \"layout\"),\n                            onPlay: onLayoutAnimationStart,\n                            onComplete: onLayoutAnimationComplete,\n                        };\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            this.animationProgress === 0) {\n                            finishAnimation(this);\n                        }\n                        this.isLead() && ((_e = (_d = this.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d));\n                    }\n                    this.targetLayout = newLayout;\n                });\n            }\n        }\n        unmount() {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            cancelSync.preRender(this.updateProjection);\n        }\n        // only on the root\n        blockUpdate() {\n            this.updateManuallyBlocked = true;\n        }\n        unblockUpdate() {\n            this.updateManuallyBlocked = false;\n        }\n        isUpdateBlocked() {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        }\n        isTreeAnimationBlocked() {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        }\n        // Note: currently only running on root node\n        startUpdate() {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n            this.animationId++;\n        }\n        willUpdate(shouldNotifyListeners = true) {\n            var _a, _b, _c;\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                node.shouldResetTransform = true;\n                node.updateScroll(\"snapshot\");\n            }\n            const { layoutId, layout } = this.options;\n            if (layoutId === undefined && !layout)\n                return;\n            const transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        }\n        // Note: Currently only running on root node\n        didUpdate() {\n            const updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            flushSync.update();\n            flushSync.preRender();\n            flushSync.render();\n        }\n        clearAllSnapshots() {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        }\n        scheduleUpdateProjection() {\n            sync.preRender(this.updateProjection, false, true);\n        }\n        scheduleCheckAfterUnmount() {\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync.postRender(() => {\n                if (this.isLayoutDirty) {\n                    this.root.didUpdate();\n                }\n                else {\n                    this.root.checkUpdateFailed();\n                }\n            });\n        }\n        /**\n         * Update measurements\n         */\n        updateSnapshot() {\n            if (this.snapshot || !this.instance)\n                return;\n            this.snapshot = this.measure();\n        }\n        updateLayout() {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (let i = 0; i < this.path.length; i++) {\n                    const node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            const prevLayout = this.layout;\n            this.layout = this.measure(false);\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.layoutBox);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notify(\"LayoutMeasure\", this.layout.layoutBox, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.layoutBox);\n        }\n        updateScroll(phase = \"measure\") {\n            let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);\n            if (this.scroll &&\n                this.scroll.animationId === this.root.animationId &&\n                this.scroll.phase === phase) {\n                needsMeasurement = false;\n            }\n            if (needsMeasurement) {\n                this.scroll = {\n                    animationId: this.root.animationId,\n                    phase,\n                    isRoot: checkIsScrollRoot(this.instance),\n                    offset: measureScroll(this.instance),\n                };\n            }\n        }\n        resetTransform() {\n            var _a;\n            if (!resetTransform)\n                return;\n            const isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            const transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            const transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        }\n        measure(removeTransform = true) {\n            const pageBox = this.measurePageBox();\n            let layoutBox = this.removeElementScroll(pageBox);\n            /**\n             * Measurements taken during the pre-render stage\n             * still have transforms applied so we remove them\n             * via calculation.\n             */\n            if (removeTransform) {\n                layoutBox = this.removeTransform(layoutBox);\n            }\n            roundBox(layoutBox);\n            return {\n                animationId: this.root.animationId,\n                measuredBox: pageBox,\n                layoutBox,\n                latestValues: {},\n                source: this.id,\n            };\n        }\n        measurePageBox() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return createBox();\n            const box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            const { scroll } = this.root;\n            if (scroll) {\n                translateAxis(box.x, scroll.offset.x);\n                translateAxis(box.y, scroll.offset.y);\n            }\n            return box;\n        }\n        removeElementScroll(box) {\n            const boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                const { scroll, options } = node;\n                if (node !== this.root && scroll && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (scroll.isRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        const { scroll: rootScroll } = this.root;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.offset.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.offset.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll.offset.x);\n                    translateAxis(boxWithoutScroll.y, scroll.offset.y);\n                }\n            }\n            return boxWithoutScroll;\n        }\n        applyTransform(box, transformOnly = false) {\n            const withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.offset.x,\n                        y: -node.scroll.offset.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        }\n        removeTransform(box) {\n            var _a;\n            const boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                const sourceBox = createBox();\n                const nodeBox = node.measurePageBox();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layoutBox, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        }\n        /**\n         *\n         */\n        setTargetDelta(delta) {\n            this.targetDelta = delta;\n            this.isProjectionDirty = true;\n            this.root.scheduleUpdateProjection();\n        }\n        setOptions(options) {\n            this.options = {\n                ...this.options,\n                ...options,\n                crossfade: options.crossfade !== undefined ? options.crossfade : true,\n            };\n        }\n        clearMeasurements() {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        }\n        /**\n         * Frame calculations\n         */\n        resolveTargetDelta() {\n            var _a;\n            /**\n             * Once the dirty status of nodes has been spread through the tree, we also\n             * need to check if we have a shared node of a different depth that has itself\n             * been dirtied.\n             */\n            const lead = this.getLead();\n            this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);\n            this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);\n            /**\n             * We don't use transform for this step of processing so we don't\n             * need to check whether any nodes have changed transform.\n             */\n            if (!this.isProjectionDirty && !this.attemptToResolveRelativeTarget)\n                return;\n            const { layout, layoutId } = this.options;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent && relativeParent.layout) {\n                    this.relativeParent = relativeParent;\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.layoutBox, relativeParent.layout.layoutBox);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.layoutBox);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.layoutBox);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.layoutBox);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent &&\n                    Boolean(relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !relativeParent.options.layoutScroll &&\n                    relativeParent.target) {\n                    this.relativeParent = relativeParent;\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n        }\n        getClosestProjectingParent() {\n            if (!this.parent ||\n                hasScale(this.parent.latestValues) ||\n                has2DTranslate(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        }\n        calcProjection() {\n            var _a;\n            const { isProjectionDirty, isTransformDirty } = this;\n            this.isProjectionDirty = this.isTransformDirty = false;\n            const lead = this.getLead();\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            let canSkip = true;\n            if (isProjectionDirty)\n                canSkip = false;\n            if (isShared && isTransformDirty)\n                canSkip = false;\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.layoutBox);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);\n            const { target } = lead;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            const prevTreeScaleX = this.treeScale.x;\n            const prevTreeScaleY = this.treeScale.y;\n            const prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        }\n        hide() {\n            this.isVisible = false;\n            // TODO: Schedule render\n        }\n        show() {\n            this.isVisible = true;\n            // TODO: Schedule render\n        }\n        scheduleRender(notifyAll = true) {\n            var _a, _b, _c;\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        }\n        setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {\n            var _a, _b;\n            const snapshot = this.snapshot;\n            const snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            const mixedValues = { ...this.latestValues };\n            const targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            const relativeLayout = createBox();\n            const isSharedLayoutAnimation = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.source) !== ((_a = this.layout) === null || _a === void 0 ? void 0 : _a.source);\n            const isOnlyMember = (((_b = this.getStack()) === null || _b === void 0 ? void 0 : _b.members.length) || 0) <= 1;\n            const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = (latest) => {\n                var _a;\n                const progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                this.setTargetDelta(targetDelta);\n                if (this.relativeTarget &&\n                    this.relativeTargetOrigin &&\n                    this.layout &&\n                    ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);\n                    mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                this.root.scheduleUpdateProjection();\n                this.scheduleRender();\n                this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        }\n        startAnimation(options) {\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync.update(() => {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                this.currentAnimation = animate(0, animationTarget, {\n                    ...options,\n                    onUpdate: (latest) => {\n                        var _a;\n                        this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    },\n                    onComplete: () => {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        this.completeAnimation();\n                    },\n                });\n                if (this.resumingFrom) {\n                    this.resumingFrom.currentAnimation = this.currentAnimation;\n                }\n                this.pendingAnimation = undefined;\n            });\n        }\n        completeAnimation() {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        }\n        finishAnimation() {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        }\n        applyTransformsToTarget() {\n            const lead = this.getLead();\n            let { targetWithTransforms, target, layout, latestValues } = lead;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            /**\n             * If we're only animating position, and this element isn't the lead element,\n             * then instead of projecting into the lead box we instead want to calculate\n             * a new target that aligns the two boxes but maintains the layout shape.\n             */\n            if (this !== lead &&\n                this.layout &&\n                layout &&\n                shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout.layoutBox)) {\n                target = this.target || createBox();\n                const xLength = calcLength(this.layout.layoutBox.x);\n                target.x.min = lead.target.x.min;\n                target.x.max = target.x.min + xLength;\n                const yLength = calcLength(this.layout.layoutBox.y);\n                target.y.min = lead.target.y.min;\n                target.y.max = target.y.min + yLength;\n            }\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its layout layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        }\n        registerSharedNode(layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            const stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        }\n        isLead() {\n            const stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        }\n        getLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        }\n        getPrevLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        }\n        getStack() {\n            const { layoutId } = this.options;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        }\n        promote({ needsReset, transition, preserveFollowOpacity, } = {}) {\n            const stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition });\n        }\n        relegate() {\n            const stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        }\n        resetRotation() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            let hasRotate = false;\n            /**\n             * An unrolled check for rotation values. Most elements don't have any rotation and\n             * skipping the nested loop and new object creation is 50% faster.\n             */\n            const { latestValues } = visualElement;\n            if (latestValues.rotate ||\n                latestValues.rotateX ||\n                latestValues.rotateY ||\n                latestValues.rotateZ) {\n                hasRotate = true;\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            const resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (let i = 0; i < transformAxes.length; i++) {\n                const key = \"rotate\" + transformAxes[i];\n                // Record the rotation and then temporarily set it to 0\n                if (latestValues[key]) {\n                    resetValues[key] = latestValues[key];\n                    visualElement.setStaticValue(key, 0);\n                }\n            }\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.render();\n            // Put back all the values we reset\n            for (const key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        }\n        getProjectionStyles(styleProp = {}) {\n            var _a, _b, _c;\n            // TODO: Return lifecycle-persistent object\n            const styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            const transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            const lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                const emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity =\n                        this.latestValues.opacity !== undefined\n                            ? this.latestValues.opacity\n                            : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            const valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            const { x, y } = this.projectionDelta;\n            styles.transformOrigin = `${x.origin * 100}% ${y.origin * 100}% 0`;\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_c = (_b = valuesToRender.opacity) !== null && _b !== void 0 ? _b : this.latestValues.opacity) !== null && _c !== void 0 ? _c : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its layout\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? valuesToRender.opacity !== undefined\n                            ? valuesToRender.opacity\n                            : \"\"\n                        : valuesToRender.opacityExit !== undefined\n                            ? valuesToRender.opacityExit\n                            : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (const key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                const { correct, applyTo } = scaleCorrectors[key];\n                const corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    const num = applyTo.length;\n                    for (let i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        }\n        clearSnapshot() {\n            this.resumeFrom = this.snapshot = undefined;\n        }\n        // Only run on root\n        resetTree() {\n            this.root.nodes.forEach((node) => { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        }\n    };\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c;\n    const snapshot = ((_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) || node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        const { layoutBox: layout, measuredBox: measuredLayout } = node.layout;\n        const { animationType } = node.options;\n        const isShared = snapshot.source !== node.layout.source;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (animationType === \"size\") {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout)) {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(layout[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        const layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout, snapshot.layoutBox);\n        const visualDelta = createDelta();\n        if (isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measuredBox);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout, snapshot.layoutBox);\n        }\n        const hasLayoutChanged = !isDeltaZero(layoutDelta);\n        let hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            const relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (relativeParent && !relativeParent.resumeFrom) {\n                const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;\n                if (parentSnapshot && parentLayout) {\n                    const relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox);\n                    const relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout, parentLayout.layoutBox);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout,\n            snapshot,\n            delta: visualDelta,\n            layoutDelta,\n            hasLayoutChanged,\n            hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_c = (_b = node.options).onExitComplete) === null || _c === void 0 ? void 0 : _c.call(_b);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction propagateDirtyNodes(node) {\n    /**\n     * Propagate isProjectionDirty. Nodes are ordered by depth, so if the parent here\n     * is dirty we can simply pass this forward.\n     */\n    node.isProjectionDirty || (node.isProjectionDirty = Boolean(node.parent && node.parent.isProjectionDirty));\n    /**\n     * Propagate isTransformDirty.\n     */\n    node.isTransformDirty || (node.isTransformDirty = Boolean(node.parent && node.parent.isTransformDirty));\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    const { visualElement } = node.options;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notify(\"BeforeLayoutMeasure\");\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = mix(delta.translate, 0, p);\n    output.scale = mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = mix(from.min, to.min, p);\n    output.max = mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nconst defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, elementId) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    let searchNode = node.root;\n    for (let i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    const searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    const element = searchElement.querySelector(`[data-projection-id=\"${elementId}\"]`);\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\nfunction shouldAnimatePositionOnly(animationType, snapshot, layout) {\n    return (animationType === \"position\" ||\n        (animationType === \"preserve-aspect\" &&\n            !isCloseTo(aspectRatio(snapshot), aspectRatio(layout), 0.2)));\n}\n\nexport { createProjectionNode, mixAxis, mixAxisDelta, mixBox, propagateDirtyNodes };\n","import { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { startAnimation } from './utils/transitions.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    startAnimation(\"\", value, to, transition);\n    return {\n        stop: () => value.stop(),\n        isAnimating: () => value.isAnimating(),\n    };\n}\n\nexport { animate };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\n\nconst DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: (ref, notify) => addDomEvent(ref, \"resize\", notify),\n    measureScroll: () => ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }),\n    checkIsScrollRoot: () => true,\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nconst rootProjectionNode = {\n    current: undefined,\n};\nconst HTMLProjectionNode = createProjectionNode({\n    measureScroll: (instance) => ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }),\n    defaultParent: () => {\n        if (!rootProjectionNode.current) {\n            const documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: (instance, value) => {\n        instance.style.transform = value !== undefined ? value : \"none\";\n    },\n    checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === \"fixed\"),\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\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 { 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","import { px, number } from 'style-value-types';\nimport { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from 'hey-listen';\nimport { transformPropOrder } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\nimport { isBrowser } from '../../../utils/is-browser.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nconst isPositionalKey = (key) => positionalKeys.has(key);\nconst hasPositionalKey = (target) => {\n    return Object.keys(target).some(isPositionalKey);\n};\nconst setAndResetVelocity = (value, to) => {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nconst isNumOrPxType = (v) => v === number || v === px;\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n    const removedTransforms = [];\n    nonTranslationalTransformKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.render();\n    return removedTransforms;\n}\nconst positionalValues = {\n    // Dimensions\n    width: ({ x }, { paddingLeft = \"0\", paddingRight = \"0\" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),\n    height: ({ y }, { paddingTop = \"0\", paddingBottom = \"0\" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),\n    top: (_bbox, { top }) => parseFloat(top),\n    left: (_bbox, { left }) => parseFloat(left),\n    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),\n    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nconst convertChangedValueTypes = (target, visualElement, changedKeys) => {\n    const originBbox = visualElement.measureViewportBox();\n    const element = visualElement.current;\n    const elementComputedStyle = getComputedStyle(element);\n    const { display } = elementComputedStyle;\n    const origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach((key) => {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.render();\n    const targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach((key) => {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        const value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nconst checkAndConvertChangedValueTypes = (visualElement, target, origin = {}, transitionEnd = {}) => {\n    target = { ...target };\n    transitionEnd = { ...transitionEnd };\n    const targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    let removedTransformValues = [];\n    let hasAttemptedToRemoveTransformValues = false;\n    const changedValueTypeKeys = [];\n    targetPositionalKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        let from = origin[key];\n        let fromType = findDimensionValueType(from);\n        const to = target[key];\n        let toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            const numKeyframes = to.length;\n            const fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (let i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                const current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\n            }\n            else {\n                // If we're going to do value conversion via DOM measurements, we first\n                // need to remove non-positional transform values that could affect the bbox measurements.\n                if (!hasAttemptedToRemoveTransformValues) {\n                    removedTransformValues =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        const scrollY = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        const convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(([key, value]) => {\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.render();\n        // Restore scroll position\n        if (isBrowser && scrollY !== null) {\n            window.scrollTo({ top: scrollY });\n        }\n        return { target: convertedTarget, transitionEnd };\n    }\n    else {\n        return { target, transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target, transitionEnd };\n}\n\nexport { BoundingBoxDimension, positionalValues, unitConversion };\n","import { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nconst parseDomVariant = (visualElement, target, origin, transitionEnd) => {\n    const resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n","import sync, { cancelSync } from 'framesync';\nimport { invariant } from 'hey-listen';\nimport { createElement } from 'react';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isRefObject } from '../utils/is-ref-object.mjs';\nimport { env } from '../utils/process.mjs';\nimport { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isWillChangeMotionValue } from '../value/use-will-change/is.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { transformProps } from './html/utils/transform.mjs';\nimport { variantPriorityOrder } from './utils/animation-state.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { isVariantLabel } from './utils/is-variant-label.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\n\nconst featureNames = Object.keys(featureDefinitions);\nconst numFeatures = featureNames.length;\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"Unmount\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n    constructor({ parent, props, reducedMotionConfig, visualState, }, options = {}) {\n        /**\n         * A reference to the current underlying Instance, e.g. a HTMLElement\n         * or Three.Mesh etc.\n         */\n        this.current = null;\n        /**\n         * A set containing references to this VisualElement's children.\n         */\n        this.children = new Set();\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        this.isVariantNode = false;\n        this.isControllingVariants = false;\n        /**\n         * Decides whether this VisualElement should animate in reduced motion\n         * mode.\n         *\n         * TODO: This is currently set on every individual VisualElement but feels\n         * like it could be set globally.\n         */\n        this.shouldReduceMotion = null;\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        this.values = new Map();\n        /**\n         * Tracks whether this VisualElement's React component is currently present\n         * within the defined React tree.\n         */\n        this.isPresent = true;\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.scheduleRender = () => sync.render(this.render, false, true);\n        const { latestValues, renderState } = visualState;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.isControllingVariants = isControllingVariants(props);\n        this.isVariantNode = isVariantNode(props);\n        if (this.isVariantNode) {\n            this.variantChildren = new Set();\n        }\n        this.manuallyAnimateOnMount = Boolean(parent && parent.current);\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props);\n        for (const key in initialMotionValues) {\n            const value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n                if (isWillChangeMotionValue(willChange)) {\n                    willChange.add(key);\n                }\n            }\n        }\n    }\n    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props) {\n        return {};\n    }\n    mount(instance) {\n        var _a;\n        this.current = instance;\n        if (this.projection) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (this.parent)\n            this.parent.children.add(this);\n        this.setProps(this.props);\n    }\n    unmount() {\n        var _a, _b, _c;\n        (_a = this.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n        cancelSync.update(this.notifyUpdate);\n        cancelSync.render(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        (_b = this.removeFromVariantTree) === null || _b === void 0 ? void 0 : _b.call(this);\n        (_c = this.parent) === null || _c === void 0 ? void 0 : _c.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        const valueIsTransform = transformProps.has(key);\n        const removeOnChange = value.onChange((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.onRenderRequest(this.scheduleRender);\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type)\n            return 0;\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    loadFeatures(renderedProps, isStrict, preloadedFeatures, projectionId, ProjectionNodeConstructor, initialLayoutGroupConfig) {\n        const features = [];\n        /**\n         * If we're in development mode, check to make sure we're not rendering a motion component\n         * as a child of LazyMotion, as this will break the file-size benefits of using it.\n         */\n        if (env !== \"production\" && preloadedFeatures && isStrict) {\n            invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n        }\n        for (let i = 0; i < numFeatures; i++) {\n            const name = featureNames[i];\n            const { isEnabled, Component } = featureDefinitions[name];\n            /**\n             * It might be possible in the future to use this moment to\n             * dynamically request functionality. In initial tests this\n             * was producing a lot of duplication amongst bundles.\n             */\n            if (isEnabled(renderedProps) && Component) {\n                features.push(createElement(Component, {\n                    key: name,\n                    ...renderedProps,\n                    visualElement: this,\n                }));\n            }\n        }\n        if (!this.projection && ProjectionNodeConstructor) {\n            this.projection = new ProjectionNodeConstructor(projectionId, this.latestValues, this.parent && this.parent.projection);\n            const { layoutId, layout, drag, dragConstraints, layoutScroll } = renderedProps;\n            this.projection.setOptions({\n                layoutId,\n                layout,\n                alwaysMeasureLayout: Boolean(drag) ||\n                    (dragConstraints && isRefObject(dragConstraints)),\n                visualElement: this,\n                scheduleRender: () => this.scheduleRender(),\n                /**\n                 * TODO: Update options in an effect. This could be tricky as it'll be too late\n                 * to update by the time layout animations run.\n                 * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n                 * ensuring it gets called if there's no potential layout animations.\n                 *\n                 */\n                animationType: typeof layout === \"string\" ? layout : \"both\",\n                initialPromotionConfig: initialLayoutGroupConfig,\n                layoutScroll,\n            });\n        }\n        return features;\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, this.options, this.props);\n    }\n    /**\n     * Measure the current viewport box with or without transforms.\n     * Only measures axis-aligned boxes, rotate and skew must be manually\n     * removed with a re-render to work.\n     */\n    measureViewportBox() {\n        return this.current\n            ? this.measureInstanceViewportBox(this.current, this.props)\n            : createBox();\n    }\n    getStaticValue(key) {\n        return this.latestValues[key];\n    }\n    setStaticValue(key, value) {\n        this.latestValues[key] = value;\n    }\n    /**\n     * Make a target animatable by Popmotion. For instance, if we're\n     * trying to animate width from 100px to 100vw we need to measure 100vw\n     * in pixels to determine what we really need to animate to. This is also\n     * pluggable to support Framer's custom value types like Color,\n     * and CSS variables.\n     */\n    makeTargetAnimatable(target, canMutate = true) {\n        return this.makeTargetAnimatableFromInstance(target, this.props, canMutate);\n    }\n    /**\n     * Update the provided props. Ensure any newly-added motion values are\n     * added to our map, old ones removed, and listeners updated.\n     */\n    setProps(props) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.props = props;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listener = props[\"on\" + key];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props), this.prevMotionValues);\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        var _a;\n        return (_a = this.props.variants) === null || _a === void 0 ? void 0 : _a[name];\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        var _a;\n        return this.isVariantNode ? this : (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getClosestVariantNode();\n    }\n    getVariantContext(startAtParent = false) {\n        var _a, _b;\n        if (startAtParent)\n            return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getVariantContext();\n        if (!this.isControllingVariants) {\n            const context = ((_b = this.parent) === null || _b === void 0 ? void 0 : _b.getVariantContext()) || {};\n            if (this.props.initial !== undefined) {\n                context.initial = this.props.initial;\n            }\n            return context;\n        }\n        const context = {};\n        for (let i = 0; i < numVariantProps; i++) {\n            const name = variantProps[i];\n            const prop = this.props[name];\n            if (isVariantLabel(prop) || prop === false) {\n                context[name] = prop;\n            }\n        }\n        return context;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        var _a;\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        if (this.hasValue(key))\n            this.removeValue(key);\n        this.values.set(key, value);\n        this.latestValues[key] = value.get();\n        this.bindToMotionValue(key, value);\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        var _a;\n        this.values.delete(key);\n        (_a = this.valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n        this.valueSubscriptions.delete(key);\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\n    /**\n     * Get a motion value for this key. If called with a default\n     * value, we'll create one if none exists.\n     */\n    getValue(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue);\n            this.addValue(key, value);\n        }\n        return value;\n    }\n    /**\n     * If we're trying to animate to a previously unencountered value,\n     * we need to check for it in our state and as a last resort read it\n     * directly from the instance (which might have performance implications).\n     */\n    readValue(key) {\n        return this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : this.readValueFromInstance(this.current, key, this.options);\n    }\n    /**\n     * Set the base target to later animate back to. This is currently\n     * only hydrated on creation and when we first read a value.\n     */\n    setBaseTarget(key, value) {\n        this.baseTarget[key] = value;\n    }\n    /**\n     * Find the base target for a value thats been removed from all animation\n     * props.\n     */\n    getBaseTarget(key) {\n        var _a;\n        const { initial } = this.props;\n        const valueFromInitial = typeof initial === \"string\" || typeof initial === \"object\"\n            ? (_a = resolveVariantFromProps(this.props, initial)) === null || _a === void 0 ? void 0 : _a[key]\n            : undefined;\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        var _a;\n        (_a = this.events[eventName]) === null || _a === void 0 ? void 0 : _a.notify(...args);\n    }\n}\nconst variantProps = [\"initial\", ...variantPriorityOrder];\nconst numVariantProps = variantProps.length;\n\nexport { VisualElement };\n","import { isBrowser } from '../is-browser.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from './state.mjs';\n\nfunction initPrefersReducedMotion() {\n    hasReducedMotionListener.current = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);\n        motionMediaQuery.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n\nexport { initPrefersReducedMotion };\n","import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"7.6.12\", `Attempting to mix Framer Motion versions ${nextValue.version} with 7.6.12 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));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { parseDomVariant } from './utils/parse-dom-variant.mjs';\nimport { VisualElement } from '../VisualElement.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    sortInstanceNodePosition(a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    }\n    getBaseTargetFromProps(props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n    makeTargetAnimatableFromInstance({ transition, transitionEnd, ...target }, { transformValues }, isMounted) {\n        let origin = getOrigin(target, transition || {}, this);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(this, target, origin);\n            const parsed = parseDomVariant(this, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return {\n            transition,\n            transitionEnd,\n            ...target,\n        };\n    }\n}\n\nexport { DOMVisualElement };\n","import { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { transformProps } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, options, props) {\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props) {\n        return scrapeMotionValuesFromProps(props);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderHTML(instance, renderState, styleProp, projection);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { transformProps } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        var _a;\n        if (transformProps.has(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return instance.getAttribute(key);\n    }\n    measureInstanceViewportBox() {\n        return createBox();\n    }\n    scrapeMotionValuesFromProps(props) {\n        return scrapeMotionValuesFromProps(props);\n    }\n    build(renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n}\n\nexport { SVGVisualElement };\n","import { HTMLVisualElement } from '../html/HTMLVisualElement.mjs';\nimport { SVGVisualElement } from '../svg/SVGVisualElement.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nconst createDomVisualElement = (Component, options) => {\n    return isSVGComponent(Component)\n        ? new SVGVisualElement(options, { enableHardwareAcceleration: false })\n        : new HTMLVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { invariant } from 'hey-listen';\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    const match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token, fallback] = match;\n    return [token, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element, depth = 1) {\n    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n    const [token, fallback] = parseCSSVariable(current);\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    const resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariable(fallback)) {\n        // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n        return getVariableValue(fallback, element, depth + 1);\n    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, { ...target }, transitionEnd) {\n    const element = visualElement.current;\n    if (!(element instanceof Element))\n        return { target, transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = { ...transitionEnd };\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.values.forEach((value) => {\n        const current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        const resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (const key in target) {\n        const current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        const resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd && transitionEnd[key] === undefined) {\n            transitionEnd[key] = current;\n        }\n    }\n    return { target, transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","import { filter, complex } from 'style-value-types';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nexport { getAnimatableNone };\n","import { color, filter } from 'style-value-types';\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 { number, px, percent, degrees, vw, vh } from 'style-value-types';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\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","/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\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","import { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { 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';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(() => visualElement.notify(\"AnimationComplete\", definition));\n}\nfunction animateVariant(visualElement, variant, options = {}) {\n    var _a;\n    const resolved = resolveVariant(visualElement, variant, options.custom);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getAnimation = resolved\n        ? () => animateTarget(visualElement, resolved, options)\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, { delay = 0, transitionOverride, type } = {}) {\n    var _a;\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = visualElement.makeTargetAnimatable(definition);\n    const willChange = visualElement.getValue(\"willChange\");\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type && ((_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.getState()[type]);\n    for (const key in target) {\n        const value = visualElement.getValue(key);\n        const valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        let valueTransition = { delay, ...transition };\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && transformProps.has(key)) {\n            valueTransition = {\n                ...valueTransition,\n                type: false,\n                delay: 0,\n            };\n        }\n        let animation = startAnimation(key, value, valueTarget, valueTransition);\n        if (isWillChangeMotionValue(willChange)) {\n            willChange.add(key);\n            animation = animation.then(() => willChange.remove(key));\n        }\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(() => {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.values.forEach((value) => value.stop());\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\n","import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { animateVisualElement } from './animation.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { AnimationType } from './types.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\nconst variantPriorityOrder = [\n    AnimationType.Animate,\n    AnimationType.InView,\n    AnimationType.Focus,\n    AnimationType.Hover,\n    AnimationType.Tap,\n    AnimationType.Drag,\n    AnimationType.Exit,\n];\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        var _a;\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 = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive, options) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        [AnimationType.Animate]: createTypeState(true),\n        [AnimationType.InView]: createTypeState(),\n        [AnimationType.Hover]: createTypeState(),\n        [AnimationType.Tap]: createTypeState(),\n        [AnimationType.Drag]: createTypeState(),\n        [AnimationType.Focus]: createTypeState(),\n        [AnimationType.Exit]: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState, variantPriorityOrder };\n","import { 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","/**\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","import { color, complex } from 'style-value-types';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\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 { complex } from 'style-value-types';\nimport { isNumericalString } from '../../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    const reversedLabels = [...variantLabels].reverse();\n    reversedLabels.forEach((key) => {\n        var _a;\n        const variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b;\n    const newValueKeys = Object.keys(target).filter((key) => !visualElement.hasValue(key));\n    const numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (let i = 0; i < numNewValues; i++) {\n        const key = newValueKeys[i];\n        const targetValue = target[key];\n        let value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\n        if (typeof value === \"string\" &&\n            (isNumericalString(value) || isZeroValueString(value))) {\n            // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n            value = parseFloat(value);\n        }\n        else if (!findValueType(value) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        if (origin[key] === undefined) {\n            origin[key] = value;\n        }\n        if (value !== null)\n            visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    const valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a;\n    const origin = {};\n    for (const key in target) {\n        const transitionOrigin = getOriginFromTransition(key, transition);\n        origin[key] =\n            transitionOrigin !== undefined\n                ? transitionOrigin\n                : (_a = visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.get();\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","/**\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","var AnimationType;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(AnimationType || (AnimationType = {}));\n\nexport { AnimationType };\n","import sync, { cancelSync } from 'framesync';\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","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nconst secondsToMilliseconds = (seconds) => seconds * 1000;\n\nexport { secondsToMilliseconds };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import { warning } from 'hey-listen';\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    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\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        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 { __rest } from 'tslib';\nimport { findSpring, calcAngularFreq } from '../utils/find-spring.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 = Object.assign({ velocity: 0.0, stiffness: 100, damping: 10, mass: 1.0, isResolvedFromDuration: false }, options);\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = Object.assign(Object.assign(Object.assign({}, springOptions), derived), { velocity: 0.0, mass: 1.0 });\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring(_a) {\n    var { from = 0.0, to = 1.0, restSpeed = 2, restDelta } = _a, options = __rest(_a, [\"from\", \"to\", \"restSpeed\", \"restDelta\"]);\n    const state = { done: false, value: from };\n    let { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    let resolveSpring = zero;\n    let resolveVelocity = zero;\n    function createSpring() {\n        const initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n        const initialDelta = to - from;\n        const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n        const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        if (restDelta === undefined) {\n            restDelta = Math.min(Math.abs(to - from) / 100, 0.4);\n        }\n        if (dampingRatio < 1) {\n            const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (to -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq) *\n                            Math.sin(angularFreq * t) +\n                            initialDelta * Math.cos(angularFreq * t)));\n            };\n            resolveVelocity = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (dampingRatio *\n                    undampedAngularFreq *\n                    envelope *\n                    ((Math.sin(angularFreq * t) *\n                        (initialVelocity +\n                            dampingRatio *\n                                undampedAngularFreq *\n                                initialDelta)) /\n                        angularFreq +\n                        initialDelta * Math.cos(angularFreq * t)) -\n                    envelope *\n                        (Math.cos(angularFreq * t) *\n                            (initialVelocity +\n                                dampingRatio *\n                                    undampedAngularFreq *\n                                    initialDelta) -\n                            angularFreq *\n                                initialDelta *\n                                Math.sin(angularFreq * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            resolveSpring = (t) => to -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta +\n                        (initialVelocity + undampedAngularFreq * initialDelta) *\n                            t);\n        }\n        else {\n            const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const freqForT = Math.min(dampedAngularFreq * t, 300);\n                return (to -\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                const currentVelocity = resolveVelocity(t) * 1000;\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(to - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? to : current;\n            return state;\n        },\n        flipTarget: () => {\n            velocity = -velocity;\n            [from, to] = [to, from];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = (a, b) => typeof a === \"string\" || typeof b === \"string\";\nconst zero = (_t) => 0;\n\nexport { spring };\n","import { interpolate } from '../../utils/interpolate.mjs';\nimport { easeInOut } from '../../easing/index.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction defaultOffset(values) {\n    const numValues = values.length;\n    return values.map((_value, i) => i !== 0 ? i / (numValues - 1) : 0);\n}\nfunction convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\nfunction keyframes({ from = 0, to = 1, ease, offset, duration = 300, }) {\n    const state = { done: false, value: from };\n    const values = Array.isArray(to) ? to : [from, to];\n    const times = convertOffsetToTimes(offset && offset.length === values.length\n        ? offset\n        : defaultOffset(values), duration);\n    function createInterpolator() {\n        return interpolate(times, values, {\n            ease: Array.isArray(ease) ? ease : defaultEasing(values, ease),\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            values.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nexport { convertOffsetToTimes, defaultEasing, defaultOffset, keyframes };\n","import { spring } from '../generators/spring.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { decay } from '../generators/decay.mjs';\n\nconst types = { keyframes, spring, decay };\nfunction detectAnimationFromOptions(config) {\n    if (Array.isArray(config.to)) {\n        return keyframes;\n    }\n    else if (types[config.type]) {\n        return types[config.type];\n    }\n    const keys = new Set(Object.keys(config));\n    if (keys.has(\"ease\") ||\n        (keys.has(\"duration\") && !keys.has(\"dampingRatio\"))) {\n        return keyframes;\n    }\n    else if (keys.has(\"dampingRatio\") ||\n        keys.has(\"stiffness\") ||\n        keys.has(\"mass\") ||\n        keys.has(\"damping\") ||\n        keys.has(\"restSpeed\") ||\n        keys.has(\"restDelta\")) {\n        return spring;\n    }\n    return keyframes;\n}\n\nexport { detectAnimationFromOptions };\n","function decay({ velocity = 0, from = 0, power = 0.8, timeConstant = 350, restDelta = 0.5, modifyTarget, }) {\n    const state = { done: false, value: from };\n    let amplitude = power * velocity;\n    const ideal = from + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    if (target !== ideal)\n        amplitude = target - from;\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 loopElapsed(elapsed, duration, delay = 0) {\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration, 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}\n\nexport { hasRepeatDelayElapsed, loopElapsed, reverseElapsed };\n","import { __rest } from 'tslib';\nimport { detectAnimationFromOptions } from './utils/detect-animation-from-options.mjs';\nimport sync, { cancelSync } from 'framesync';\nimport { interpolate } from '../utils/interpolate.mjs';\nimport { hasRepeatDelayElapsed, reverseElapsed, loopElapsed } from './utils/elapsed.mjs';\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 animate(_a) {\n    var _b, _c;\n    var { from, autoplay = true, driver = framesync, elapsed = 0, repeat: repeatMax = 0, repeatType = \"loop\", repeatDelay = 0, onPlay, onStop, onComplete, onRepeat, onUpdate } = _a, options = __rest(_a, [\"from\", \"autoplay\", \"driver\", \"elapsed\", \"repeat\", \"repeatType\", \"repeatDelay\", \"onPlay\", \"onStop\", \"onComplete\", \"onRepeat\", \"onUpdate\"]);\n    let { to } = options;\n    let driverControls;\n    let repeatCount = 0;\n    let computedDuration = options.duration;\n    let latest;\n    let isComplete = false;\n    let isForwardPlayback = true;\n    let interpolateFromNumber;\n    const animator = detectAnimationFromOptions(options);\n    if ((_c = (_b = animator).needsInterpolation) === null || _c === void 0 ? void 0 : _c.call(_b, from, to)) {\n        interpolateFromNumber = interpolate([0, 100], [from, to], {\n            clamp: false,\n        });\n        from = 0;\n        to = 100;\n    }\n    const animation = animator(Object.assign(Object.assign({}, options), { from, to }));\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.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            const state = animation.next(Math.max(0, elapsed));\n            latest = state.value;\n            if (interpolateFromNumber)\n                latest = interpolateFromNumber(latest);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(latest);\n        if (isComplete) {\n            if (repeatCount === 0)\n                computedDuration !== null && computedDuration !== void 0 ? computedDuration : (computedDuration = elapsed);\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay === null || onPlay === void 0 ? void 0 : onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: () => {\n            onStop === null || onStop === void 0 ? void 0 : onStop();\n            driverControls.stop();\n        },\n    };\n}\n\nexport { animate };\n","const reverseEasing = easing => p => 1 - easing(1 - p);\nconst mirrorEasing = easing => p => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\nconst createExpoIn = (power) => p => Math.pow(p, power);\nconst createBackIn = (power) => p => p * p * ((power + 1) * p - power);\nconst createAnticipate = (power) => {\n    const backEasing = createBackIn(power);\n    return p => (p *= 2) < 1\n        ? 0.5 * backEasing(p)\n        : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n};\n\nexport { createAnticipate, createBackIn, createExpoIn, mirrorEasing, reverseEasing };\n","import { createExpoIn, reverseEasing, mirrorEasing, createBackIn, createAnticipate } from './utils.mjs';\n\nconst DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nconst BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nconst BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nconst BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nconst linear = p => p;\nconst easeIn = createExpoIn(2);\nconst easeOut = reverseEasing(easeIn);\nconst easeInOut = mirrorEasing(easeIn);\nconst circIn = p => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\nconst backIn = createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nconst backOut = reverseEasing(backIn);\nconst backInOut = mirrorEasing(backIn);\nconst anticipate = createAnticipate(DEFAULT_OVERSHOOT_STRENGTH);\nconst ca = 4356.0 / 361.0;\nconst cb = 35442.0 / 1805.0;\nconst cc = 16061.0 / 1805.0;\nconst bounceOut = (p) => {\n    if (p === 1 || p === 0)\n        return p;\n    const p2 = p * p;\n    return p < BOUNCE_FIRST_THRESHOLD\n        ? 7.5625 * p2\n        : p < BOUNCE_SECOND_THRESHOLD\n            ? 9.075 * p2 - 9.9 * p + 3.4\n            : p < BOUNCE_THIRD_THRESHOLD\n                ? ca * p2 - cb * p + cc\n                : 10.8 * p * p - 20.52 * p + 10.72;\n};\nconst bounceIn = reverseEasing(bounceOut);\nconst bounceInOut = (p) => p < 0.5\n    ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0))\n    : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n\nexport { anticipate, backIn, backInOut, backOut, bounceIn, bounceInOut, bounceOut, circIn, circInOut, circOut, easeIn, easeInOut, easeOut, linear };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","const isPoint = (point) => point.hasOwnProperty('x') && point.hasOwnProperty('y');\n\nexport { isPoint };\n","import { isPoint } from './is-point.mjs';\n\nconst isPoint3D = (point) => isPoint(point) && point.hasOwnProperty('z');\n\nexport { isPoint3D };\n","import { isPoint } from './is-point.mjs';\nimport { isPoint3D } from './is-point-3d.mjs';\nimport { isNum } from './inc.mjs';\n\nconst distance1D = (a, b) => Math.abs(a - b);\nfunction distance(a, b) {\n    if (isNum(a) && isNum(b)) {\n        return distance1D(a, b);\n    }\n    else if (isPoint(a) && isPoint(b)) {\n        const xDelta = distance1D(a.x, b.x);\n        const yDelta = distance1D(a.y, b.y);\n        const zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n    }\n}\n\nexport { distance };\n","const zeroPoint = {\n    x: 0,\n    y: 0,\n    z: 0\n};\nconst isNum = (v) => typeof v === 'number';\n\nexport { isNum, zeroPoint };\n","function hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n","import { mix } from './mix.mjs';\nimport { hsla, rgba, hex } from 'style-value-types';\nimport { invariant } from 'hey-listen';\nimport { hslaToRgba } from './hsla-to-rgba.mjs';\n\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const toExpo = to * to;\n    return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nconst notAnimatable = (color) => `'${color}' is not an animatable color. Use the equivalent color code instead.`;\nconst mixColor = (from, to) => {\n    let fromColorType = getColorType(from);\n    let toColorType = getColorType(to);\n    invariant(!!fromColorType, notAnimatable(from));\n    invariant(!!toColorType, notAnimatable(to));\n    let fromColor = fromColorType.parse(from);\n    let toColor = toColorType.parse(to);\n    if (fromColorType === hsla) {\n        fromColor = hslaToRgba(fromColor);\n        fromColorType = rgba;\n    }\n    if (toColorType === hsla) {\n        toColor = hslaToRgba(toColor);\n        toColorType = rgba;\n    }\n    const blended = Object.assign({}, fromColor);\n    return (v) => {\n        for (const key in blended) {\n            if (key !== \"alpha\") {\n                blended[key] = mixLinearColor(fromColor[key], toColor[key], v);\n            }\n        }\n        blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n        return fromColorType.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","import { complex, color } from 'style-value-types';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { isNum } from './inc.mjs';\nimport { pipe } from './pipe.mjs';\nimport { warning } from 'hey-listen';\n\nfunction getMixer(origin, target) {\n    if (isNum(origin)) {\n        return (v) => mix(origin, target, v);\n    }\n    else if (color.test(origin)) {\n        return mixColor(origin, target);\n    }\n    else {\n        return mixComplex(origin, target);\n    }\n}\nconst mixArray = (from, to) => {\n    const output = [...from];\n    const numValues = output.length;\n    const blendValue = from.map((fromThis, i) => getMixer(fromThis, to[i]));\n    return (v) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](v);\n        }\n        return output;\n    };\n};\nconst mixObject = (origin, target) => {\n    const output = Object.assign(Object.assign({}, origin), target);\n    const blendValue = {};\n    for (const key in output) {\n        if (origin[key] !== undefined && target[key] !== undefined) {\n            blendValue[key] = getMixer(origin[key], target[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n};\nfunction analyse(value) {\n    const parsed = complex.parse(value);\n    const numValues = parsed.length;\n    let numNumbers = 0;\n    let numRGB = 0;\n    let numHSL = 0;\n    for (let i = 0; i < numValues; i++) {\n        if (numNumbers || typeof parsed[i] === \"number\") {\n            numNumbers++;\n        }\n        else {\n            if (parsed[i].hue !== undefined) {\n                numHSL++;\n            }\n            else {\n                numRGB++;\n            }\n        }\n    }\n    return { parsed, numNumbers, numRGB, numHSL };\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyse(origin);\n    const targetStats = analyse(target);\n    const canInterpolate = originStats.numHSL === targetStats.numHSL &&\n        originStats.numRGB === targetStats.numRGB &&\n        originStats.numNumbers >= targetStats.numNumbers;\n    if (canInterpolate) {\n        return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n        return (p) => `${p > 0 ? target : origin}`;\n    }\n};\n\nexport { mixArray, mixComplex, mixObject };\n","import { progress } from './progress.mjs';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { mixComplex, mixArray, mixObject } from './mix-complex.mjs';\nimport { color } from 'style-value-types';\nimport { clamp } from './clamp.mjs';\nimport { pipe } from './pipe.mjs';\nimport { invariant } from 'hey-listen';\n\nconst mixNumber = (from, to) => (p) => mix(from, to, p);\nfunction detectMixerFactory(v) {\n    if (typeof v === 'number') {\n        return mixNumber;\n    }\n    else if (typeof v === 'string') {\n        if (color.test(v)) {\n            return mixColor;\n        }\n        else {\n            return mixComplex;\n        }\n    }\n    else if (Array.isArray(v)) {\n        return mixArray;\n    }\n    else if (typeof v === 'object') {\n        return mixObject;\n    }\n}\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || detectMixerFactory(output[0]);\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\nfunction fastInterpolate([from, to], [mixer]) {\n    return (v) => mixer(progress(from, to, v));\n}\nfunction slowInterpolate(input, mixers) {\n    const inputLength = input.length;\n    const lastInputIndex = inputLength - 1;\n    return (v) => {\n        let mixerIndex = 0;\n        let foundMixerIndex = false;\n        if (v <= input[0]) {\n            foundMixerIndex = true;\n        }\n        else if (v >= input[lastInputIndex]) {\n            mixerIndex = lastInputIndex - 1;\n            foundMixerIndex = true;\n        }\n        if (!foundMixerIndex) {\n            let i = 1;\n            for (; i < inputLength; i++) {\n                if (input[i] > v || i === lastInputIndex) {\n                    break;\n                }\n            }\n            mixerIndex = i - 1;\n        }\n        const progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n        return mixers[mixerIndex](progressInRange);\n    };\n}\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n    invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n    if (input[0] > input[inputLength - 1]) {\n        input = [].concat(input);\n        output = [].concat(output);\n        input.reverse();\n        output.reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const interpolator = inputLength === 2\n        ? fastInterpolate(input, mixers)\n        : slowInterpolate(input, mixers);\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n","const mix = (from, to, progress) => -progress * from + progress * to + from;\n\nexport { mix };\n","const combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\n","const progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = '';\n    let g = '';\n    let b = '';\n    let a = '';\n    if (v.length > 5) {\n        r = v.substr(1, 2);\n        g = v.substr(3, 2);\n        b = v.substr(5, 2);\n        a = v.substr(7, 2);\n    }\n    else {\n        r = v.substr(1, 1);\n        g = v.substr(2, 1);\n        b = v.substr(3, 1);\n        a = v.substr(4, 1);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString('#'),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: isColorString('hsl', 'hue'),\n    parse: splitColor('hue', 'saturation', 'lightness'),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return ('hsla(' +\n            Math.round(hue) +\n            ', ' +\n            percent.transform(sanitize(saturation)) +\n            ', ' +\n            percent.transform(sanitize(lightness)) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')');\n    },\n};\n\nexport { hsla };\n","import { isString } from '../utils.mjs';\nimport { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty('red')\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { number, alpha } from '../numbers/index.mjs';\nimport { sanitize, clamp } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = clamp(0, 255);\nconst rgbUnit = Object.assign(Object.assign({}, number), { transform: (v) => Math.round(clampRgbUnit(v)) });\nconst rgba = {\n    test: isColorString('rgb', 'red'),\n    parse: splitColor('red', 'green', 'blue'),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => 'rgba(' +\n        rgbUnit.transform(red) +\n        ', ' +\n        rgbUnit.transform(green) +\n        ', ' +\n        rgbUnit.transform(blue) +\n        ', ' +\n        sanitize(alpha.transform(alpha$1)) +\n        ')',\n};\n\nexport { rgbUnit, rgba };\n","import { isString, singleColorRegex, floatRegex } from '../utils.mjs';\n\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\nconst maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n    let [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 = Object.assign(Object.assign({}, complex), { getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n    } });\n\nexport { filter };\n","import { color } from '../color/index.mjs';\nimport { number } from '../numbers/index.mjs';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.mjs';\n\nconst colorToken = '${c}';\nconst numberToken = '${n}';\nfunction test(v) {\n    var _a, _b, _c, _d;\n    return (isNaN(v) &&\n        isString(v) &&\n        ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0);\n}\nfunction analyse(v) {\n    if (typeof v === 'number')\n        v = `${v}`;\n    const values = [];\n    let numColors = 0;\n    const colors = v.match(colorRegex);\n    if (colors) {\n        numColors = colors.length;\n        v = v.replace(colorRegex, colorToken);\n        values.push(...colors.map(color.parse));\n    }\n    const numbers = v.match(floatRegex);\n    if (numbers) {\n        v = v.replace(floatRegex, numberToken);\n        values.push(...numbers.map(number.parse));\n    }\n    return { values, numColors, tokenised: v };\n}\nfunction parse(v) {\n    return analyse(v).values;\n}\nfunction createTransformer(v) {\n    const { values, numColors, tokenised } = analyse(v);\n    const numValues = values.length;\n    return (v) => {\n        let output = tokenised;\n        for (let i = 0; i < numValues; i++) {\n            output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === 'number' ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parse(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = { test, parse, createTransformer, getAnimatableNone };\n\nexport { complex };\n"],"names":["warning","invariant","a","a1","a2","b","c","calcBezier","t","getSlope","kSampleStepSize","cubicBezier","mX1","mY1","mX2","mY2","linear","sampleValues","Float32Array","i","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","Math","abs","binarySubdivide","easingLookup","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","definition","Array","isArray","length","undefined","isAnimatable","key","value","complex","startsWith","underDampedSpring","type","stiffness","damping","restSpeed","criticallyDampedSpring","to","sqrt","linearTween","ease","duration","keyframes","values","defaultTransitions","x","y","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","color","default","instantAnimationState","legacyRepeatWarning","convertTransitionToAnimationOptions","times","yoyo","flip","loop","transition","options","secondsToMilliseconds","repeatDelay","isEasingArray","map","repeatType","repeat","getDelayFromTransition","_a","_b","getValueTransition","delay","getPopmotionAnimationOptions","from","hydrateKeyframes","when","delayChildren","staggerChildren","staggerDirection","Object","keys","isTransitionDefined","valueKey","transitionFactory","isKeyframesTarget","getDefaultTransition","getAnimation","target","onComplete","valueTransition","origin","get","isTargetAnimatable","getAnimatableNone","isZero","getZeroUnit","isOriginAnimatable","velocity","getVelocity","onUpdate","v","set","currentAnimation","min","max","power","timeConstant","bounceStiffness","bounceDamping","restDelta","modifyTarget","driver","onStop","isOutOfBounds","boundaryNearest","startAnimation","stop","animate","assign","call","startSpring","prev","current","boundary","heading","velocityPerSecond","getFrameData","delta","inertia","finalTarget","resolveFinalValueInKeyframes","parseFloat","indexOf","potentialUnitType","start","controls","cancelDelay","animation","delayBy","usePresence","context","useContext","PresenceContext","isPresent","onExitComplete","register","id","useId","useEffect","filterPrimaryPointer","eventHandler","event","isMouseEvent","MouseEvent","button","defaultPagePoint","pageX","pageY","pointFromTouch","e","pointType","primaryTouch","touches","changedTouches","point","pointFromMouse","extractEventInfo","isTouchEvent","wrapHandler","handler","shouldFilterPrimaryPointer","listener","addDomEvent","eventName","passive","addEventListener","removeEventListener","useDomEvent","ref","element","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","name","isBrowser","window","onpointerdown","ontouchstart","onmousedown","addPointerEvent","usePointerEvent","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal","openVertical","isDragActive","openGestureLock","PointerEvent","pointerType","animations","makeRenderlessComponent","visualElement","animationState","createAnimationState","isAnimationControls","subscribe","exit","props","custom","safeToRemove","presenceContext","setActive","AnimationType","then","PanSession","handlers","transformPagePoint","this","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","distance","offset","timestamp","push","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","sync","end","onEnd","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","pipe","cancelSync","subtractPoint","lastDevicePoint","startDevicePoint","timeDelta","timestampedPoint","lastPoint","time","currentVelocity","Infinity","calcRelativeAxisConstraints","axis","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","elementDragControls","WeakMap","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","originPoint","constraints","hasMutatedConstraints","elastic","createBox","originEvent","snapToCursor","stopAnimation","getProps","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","eachAxis","getAxisMotionValue","percent","measuredAxis","layout","layoutBox","calcLength","dragDirectionLock","onDirectionLock","onDrag","getCurrentDirection","updateAxis","render","panSession","getTransformPagePoint","cancel","onDragEnd","_point","shouldDrag","axisValue","next","mix","applyConstraints","dragConstraints","prevConstraints","isRefObject","resolveRefConstraints","top","left","bottom","right","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","measurePageBox","root","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","convertBoundingBoxToBox","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","startAxisValueAnimation","Promise","all","dragKey","toUpperCase","externalMotionValue","getValue","initial","boxProgress","latest","source","sourceLength","targetLength","progress","clamp","calcOrigin","transformTemplate","style","transform","updateScroll","updateLayout","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","scalePositionWithinConstraints","stopLayoutUpdateListener","hasLayoutChanged","motionValue","translate","direction","lockThreshold","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","MotionConfigContext","updateHandlers","useUnmountEffect","groupDragControls","dragControls","useConstant","addListeners","createHoverEvent","isActive","callback","isNodeOrChild","parent","child","parentElement","observerCallbacks","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","forEach","observeIntersection","rootInteresectionObserver","lookupRoot","document","has","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","delete","unobserve","thresholdNames","some","useIntersectionObserver","shouldObserve","state","rootMargin","margin","amount","once","threshold","isIntersecting","isInView","hasEnteredView","onViewportEnter","onViewportLeave","useMissingIntersectionObserver","fallback","env","warnOnce","requestAnimationFrame","gestureAnimations","inView","whileInView","viewport","Boolean","tap","onTap","onTapStart","onTapCancel","whileTap","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","checkPointerEnd","onPointerUp","onPointerCancel","focus","whileFocus","hover","onHoverStart","onHoverEnd","whileHover","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","replace","cssVariableRegex","match","shadow","template","xScale","yScale","averageScale","output","cssVariable","MeasureLayoutWithContext","layoutGroup","switchLayoutGroup","layoutId","addScaleCorrector","defaultScaleCorrectors","group","add","didUpdate","setOptions","globalProjectionState","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","isLead","promoteContext","scheduleCheckAfterUnmount","remove","deregister","React__default","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","SwitchLayoutGroupContext","hook","transformBoxPoints","topLeft","bottomRight","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","applyTreeDeltas","treePath","isSharedTransition","treeLength","instance","display","layoutScroll","scroll","transformBox","hasTransform","latestValues","translateAxis","transformAxis","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","isNear","maxDistance","calcAxisDelta","isNaN","calcBoxDelta","originX","originY","calcRelativeAxis","relative","calcRelativeBox","calcRelativeAxisPosition","calcRelativePosition","createDelta","borders","numBorders","asNumber","isPx","mixValues","follow","lead","shouldCrossfadeOpacity","isOnlyMember","_c","_d","easeCrossfadeIn","opacityExit","easeCrossfadeOut","borderLabel","followRadius","getRadius","leadRadius","radiusName","compress","easing","p","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","aspectRatio","NodeStack","addUniqueItem","scheduleRender","removeItem","prevLead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isUpdating","isLayoutDirty","crossfade","hide","_e","resumingFrom","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","depth","FlatTree","children","isDirty","sort","transformAxes","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","elementId","animationId","Set","isTreeAnimating","isTransformDirty","isProjectionDirty","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","Map","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","propagateDirtyNodes","resolveTargetDelta","calcProjection","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","SubscriptionManager","subscriptionManager","args","notify","SVGElement","tagName","mount","resizeUnblockUpdate","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","shouldReduceMotion","isUpdateBlocked","resetRotation","shouldNotifyListeners","startUpdate","prevTransformTemplateValue","updateSnapshot","notifyListeners","unblockUpdate","clearMeasurements","size","mountNodeEarly","clear","resetTransformStyle","notifyLayoutUpdate","flushSync","clearSnapshot","removeLeadSnapshots","measure","alwaysMeasureLayout","prevLayout","layoutCorrected","phase","needsMeasurement","isRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","removeTransform","pageBox","removeElementScroll","roundBox","measuredBox","measureViewportBox","boxWithoutScroll","rootScroll","transformOnly","withTransforms","boxWithoutTransform","hasScale","targetDelta","scheduleUpdateProjection","getLead","attemptToResolveRelativeTarget","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","applyTransform","has2DTranslate","isShared","canSkip","pendingAnimation","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","setTargetDelta","mixBox","isMotionValue","isAnimating","completeAnimation","exitAnimationComplete","shouldAnimatePositionOnly","animationType","xLength","yLength","initialPromotionConfig","shouldPreserveFollowOpacity","stack","hasRotate","resetValues","setStaticValue","styleProp","styles","visibility","pointerEvents","resolveMotionValue","emptyStyles","valuesToRender","applyTransformsToTarget","transformOrigin","scaleCorrectors","corrected","num","hasListeners","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","removeLeadSnapshot","mixAxis","searchNode","querySelector","roundAxis","round","isCloseTo","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","rootProjectionNode","HTMLProjectionNode","documentNode","getComputedStyle","position","isIdentityScale","is2DTranslate","getBoundingClientRect","viewportBox","BoundingBoxDimension","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","number","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","transformPropOrder","removeNonTranslationalTransform","removedTransforms","positionalValues","width","paddingLeft","paddingRight","height","paddingTop","paddingBottom","convertChangedValueTypes","changedKeys","originBbox","elementComputedStyle","targetBbox","unitConversion","transitionEnd","hasPositionalKey","targetPositionalKeys","filter","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","hasValue","toType","fromType","findDimensionValueType","numKeyframes","fromIndex","scrollY","pageYOffset","convertedTarget","scrollTo","checkAndConvertChangedValueTypes","prefersReducedMotion","hasReducedMotionListener","featureNames","featureDefinitions","numFeatures","propEventHandlers","VisualElement","reducedMotionConfig","visualState","isVariantNode","isControllingVariants","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","triggerBuild","renderInstance","renderState","baseTarget","initialValues","variantChildren","manuallyAnimateOnMount","scrapeMotionValuesFromProps","willChange","initialMotionValues","isWillChangeMotionValue","_props","removeFromVariantTree","addVariantChild","bindToMotionValue","matchMedia","motionMediaQuery","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","setProps","unmount","valueIsTransform","transformProps","removeOnChange","onChange","latestValue","removeOnRenderRequest","onRenderRequest","other","sortInstanceNodePosition","renderedProps","isStrict","preloadedFeatures","projectionId","ProjectionNodeConstructor","initialLayoutGroupConfig","features","isEnabled","Component","createElement","build","measureInstanceViewportBox","canMutate","makeTargetAnimatableFromInstance","on","nextValue","prevValue","addValue","existingValue","hasAnimated","getStaticValue","removeValue","updateMotionValuesFromProps","variants","getClosestVariantNode","startAtParent","getVariantContext","numVariantProps","variantProps","prop","isVariantLabel","closestVariantNode","removeValueFromRenderState","defaultValue","readValueFromInstance","valueFromInitial","resolveVariantFromProps","getBaseTargetFromProps","variantPriorityOrder","DOMVisualElement","compareDocumentPosition","vars","isMounted","transformValues","getOrigin","checkTargetForNewValues","parsed","resolved","resolveCSSVariables","parseDomVariant","HTMLVisualElement","defaultType","getDefaultValueType","computedStyle","isCSSVariable","getPropertyValue","trim","buildHTMLStyles","renderHTML","SVGVisualElement","camelCaseAttributes","camelToDash","getAttribute","buildSVGAttrs","renderSVG","createDomVisualElement","isSVGComponent","enableHardwareAcceleration","parseCSSVariable","exec","getVariableValue","token","Element","defaultValueType","defaultValueTypes","numberValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","dimensionValueTypes","degrees","vw","vh","test","parse","find","testValueType","shallowCompare","prevLength","animateVariant","variant","resolveVariant","transitionOverride","animateTarget","resolve","getChildAnimations","forwardDelay","animateChildren","first","last","makeTargetAnimatable","animationTypeState","getState","valueTarget","shouldBlockAnimation","setTarget","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","sortNodePosition","protectedKeys","needsAnimating","shouldBlock","hasOwnProperty","reversePriorityOrder","reverse","numAnimationTypes","animateList","resolvedDefinition","animateVisualElement","createTypeState","createState","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","removedKeys","encounteredKeys","removedVariantIndex","typeState","propIsVariant","activeDelta","isInherited","prevProp","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","prevResolvedValues","allKeys","markToAnimate","blockInitialAnimation","fallbackAnimation","fallbackTarget","getBaseTarget","shouldAnimate","setAnimateFunction","makeAnimator","getCurrent","isZeroValueString","valueTypes","findValueType","setMotionValue","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","getOriginFromTransition","transitionOrigin","timeout","performance","now","checkElapsed","elapsed","seconds","__rest","s","prototype","getOwnPropertySymbols","propertyIsEnumerable","create","safeMin","findSpring","envelope","derivative","bounce","mass","maxDuration","dampingRatio","undampedFreq","exponentialDecay","calcAngularFreq","exp","d","pow","f","g","initialGuess","result","approximateRoot","durationKeys","physicsKeys","isSpringType","spring","done","springOptions","isResolvedFromDuration","derived","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","angularFreq","sin","cos","dampedAngularFreq","freqForT","sinh","cosh","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","_t","defaultEasing","splice","o","convertOffsetToTimes","numValues","_value","defaultOffset","createInterpolator","interpolate","interpolator","types","decay","amplitude","ideal","loopElapsed","framesync","update","passTimestamp","driverControls","interpolateFromNumber","autoplay","repeatMax","onRepeat","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","config","detectAnimationFromOptions","reverseElapsed","hasRepeatDelayElapsed","reverseEasing","mirrorEasing","createBackIn","acos","backEasing","createAnticipate","p2","isPoint","isPoint3D","distance1D","isNum","xDelta","yDelta","zDelta","hueToRgb","q","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","mixLinearColor","fromExpo","toExpo","colorTypes","hex","rgba","hsla","getColorType","notAnimatable","mixColor","fromColorType","toColorType","fromColor","toColor","blended","getMixer","mixComplex","mixArray","blendValue","fromThis","mixObject","analyse","numNumbers","numRGB","numHSL","originStats","targetStats","mixNumber","createMixers","customMixer","mixers","mixerFactory","numMixers","mixer","easingFunction","fastInterpolate","slowInterpolate","input","inputLength","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","isClamp","concat","combineFunctions","transformers","toFromDifference","isColorString","r","substr","parseInt","splitColor","alpha$1","sanitize","isString","clampRgbUnit","rgbUnit","testProp","singleColorRegex","aName","bName","cName","floatRegex","maxDefaults","applyDefaultFilter","slice","unit","functionRegex","functions","join","colorToken","numberToken","numColors","colors","colorRegex","numbers","tokenised","createTransformer","convertNumbersToZero","transformer"],"sourceRoot":""}