{"version":3,"file":"static/chunks/3158-fda6be86a2b44ca4.js","mappings":"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","sources":["webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-waapi.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/generators/inertia.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/offsets/time.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/generators/spring/defaults.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/utils/is-transition-defined.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/anticipate.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/back.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/circ.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/ease.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/easing/utils/map.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/events/add-dom-event.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/frameloop/sync-time.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/motion/features/Feature.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/utils/get-variant-context.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/motion/features/animation/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/gestures/hover.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/gestures/focus.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/gestures/press.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/VisualElement.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/animation/utils/is-none.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/html/utils/keys-position.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/store.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/stats/animation-count.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/array.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/interpolate.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/mix/immediate.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/mix/color.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/mix/visibility.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/mix/complex.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/mix/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/mix/number.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/offsets/default.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/offsets/fill.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/pipe.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/color/hex.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/color/hsla.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/color/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/color/rgba.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/utils/is-nullish.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/utils/single-color-regex.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/color/utils.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/utils/color-regex.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/complex/index.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/utils/float-regex.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/types/utils/sanitize.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","webpack://_N_E/../common/node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/utils/supports/scroll-timeline.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/controls/BaseGroup.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/controls/Group.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/utils/get-value-transition.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/waapi/utils/attach-timeline.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/waapi/NativeAnimationControls.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/utils/is-bezier-definition.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/utils/supports/flags.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/utils/supports/memo.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/utils/supports/linear-easing.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/waapi/utils/linear.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/waapi/utils/easing.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/drag/state/is-active.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/utils/resolve-elements.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/utils/setup.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/hover.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/utils/capture-pointer.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/utils/is-node-or-child.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/press/utils/state.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/press/utils/keyboard.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/press/index.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/waapi/utils/convert-options.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/animation/waapi/PseudoAnimation.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/view/utils/css.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/view/start.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/view/index.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/gestures/drag/state/set-active.mjs","webpack://_N_E/../common/node_modules/motion-dom/dist/es/index.mjs","webpack://_N_E/../common/node_modules/motion-utils/dist/es/errors.mjs","webpack://_N_E/../common/node_modules/motion-utils/dist/es/memo.mjs","webpack://_N_E/../common/node_modules/motion-utils/dist/es/progress.mjs","webpack://_N_E/../common/node_modules/motion-utils/dist/es/time-conversion.mjs"],"sourcesContent":["import { supportsLinearEasing, attachTimeline, isGenerator, isWaapiSupportedEasing } from 'motion-dom';\nimport { millisecondsToSeconds, secondsToMilliseconds, noop } from 'motion-utils';\nimport { anticipate } from '../../easing/anticipate.mjs';\nimport { backInOut } from '../../easing/back.mjs';\nimport { circInOut } from '../../easing/circ.mjs';\nimport { DOMKeyframesResolver } from '../../render/dom/DOMKeyframesResolver.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { MainThreadAnimation } from './MainThreadAnimation.mjs';\nimport { acceleratedValues } from './utils/accelerated-values.mjs';\nimport { startWaapiAnimation } from './waapi/index.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\nimport { supportsWaapi } from './waapi/utils/supports-waapi.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxDuration = 20000;\n/**\n * Check if an animation can run natively via WAAPI or requires pregenerated keyframes.\n * WAAPI doesn't support spring or function easings so we run these as JS animation before\n * handing off.\n */\nfunction requiresPregeneratedKeyframes(options) {\n    return (isGenerator(options.type) ||\n        options.type === \"spring\" ||\n        !isWaapiSupportedEasing(options.ease));\n}\nfunction pregenerateKeyframes(keyframes, options) {\n    /**\n     * Create a main-thread animation to pregenerate keyframes.\n     * We sample this at regular intervals to generate keyframes that we then\n     * linearly interpolate between.\n     */\n    const sampleAnimation = new MainThreadAnimation({\n        ...options,\n        keyframes,\n        repeat: 0,\n        delay: 0,\n        isGenerator: true,\n    });\n    let state = { done: false, value: keyframes[0] };\n    const pregeneratedKeyframes = [];\n    /**\n     * Bail after 20 seconds of pre-generated keyframes as it's likely\n     * we're heading for an infinite loop.\n     */\n    let t = 0;\n    while (!state.done && t < maxDuration) {\n        state = sampleAnimation.sample(t);\n        pregeneratedKeyframes.push(state.value);\n        t += sampleDelta;\n    }\n    return {\n        times: undefined,\n        keyframes: pregeneratedKeyframes,\n        duration: t - sampleDelta,\n        ease: \"linear\",\n    };\n}\nconst unsupportedEasingFunctions = {\n    anticipate,\n    backInOut,\n    circInOut,\n};\nfunction isUnsupportedEase(key) {\n    return key in unsupportedEasingFunctions;\n}\nclass AcceleratedAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        const { name, motionValue, element, keyframes } = this.options;\n        this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue, element);\n        this.resolver.scheduleResolve();\n    }\n    initPlayback(keyframes, finalKeyframe) {\n        let { duration = 300, times, ease, type, motionValue, name, startTime, } = this.options;\n        /**\n         * If element has since been unmounted, return false to indicate\n         * the animation failed to initialised.\n         */\n        if (!motionValue.owner || !motionValue.owner.current) {\n            return false;\n        }\n        /**\n         * If the user has provided an easing function name that isn't supported\n         * by WAAPI (like \"anticipate\"), we need to provide the corressponding\n         * function. This will later get converted to a linear() easing function.\n         */\n        if (typeof ease === \"string\" &&\n            supportsLinearEasing() &&\n            isUnsupportedEase(ease)) {\n            ease = unsupportedEasingFunctions[ease];\n        }\n        /**\n         * If this animation needs pre-generated keyframes then generate.\n         */\n        if (requiresPregeneratedKeyframes(this.options)) {\n            const { onComplete, onUpdate, motionValue, element, ...options } = this.options;\n            const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);\n            keyframes = pregeneratedAnimation.keyframes;\n            // If this is a very short animation, ensure we have\n            // at least two keyframes to animate between as older browsers\n            // can't animate between a single keyframe.\n            if (keyframes.length === 1) {\n                keyframes[1] = keyframes[0];\n            }\n            duration = pregeneratedAnimation.duration;\n            times = pregeneratedAnimation.times;\n            ease = pregeneratedAnimation.ease;\n            type = \"keyframes\";\n        }\n        const animation = startWaapiAnimation(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });\n        // Override the browser calculated startTime with one synchronised to other JS\n        // and WAAPI animations starting this event loop.\n        animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();\n        if (this.pendingTimeline) {\n            attachTimeline(animation, this.pendingTimeline);\n            this.pendingTimeline = undefined;\n        }\n        else {\n            /**\n             * Prefer the `onfinish` prop as it's more widely supported than\n             * the `finished` promise.\n             *\n             * Here, we synchronously set the provided MotionValue to the end\n             * keyframe. If we didn't, when the WAAPI animation is finished it would\n             * be removed from the element which would then revert to its old styles.\n             */\n            animation.onfinish = () => {\n                const { onComplete } = this.options;\n                motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.cancel();\n                this.resolveFinishedPromise();\n            };\n        }\n        return {\n            animation,\n            duration,\n            times,\n            type,\n            ease,\n            keyframes: keyframes,\n        };\n    }\n    get duration() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { duration } = resolved;\n        return millisecondsToSeconds(duration);\n    }\n    get time() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { animation } = resolved;\n        return millisecondsToSeconds(animation.currentTime || 0);\n    }\n    set time(newTime) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.currentTime = secondsToMilliseconds(newTime);\n    }\n    get speed() {\n        const { resolved } = this;\n        if (!resolved)\n            return 1;\n        const { animation } = resolved;\n        return animation.playbackRate;\n    }\n    set speed(newSpeed) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.playbackRate = newSpeed;\n    }\n    get state() {\n        const { resolved } = this;\n        if (!resolved)\n            return \"idle\";\n        const { animation } = resolved;\n        return animation.playState;\n    }\n    get startTime() {\n        const { resolved } = this;\n        if (!resolved)\n            return null;\n        const { animation } = resolved;\n        // Coerce to number as TypeScript incorrectly types this\n        // as CSSNumberish\n        return animation.startTime;\n    }\n    /**\n     * Replace the default DocumentTimeline with another AnimationTimeline.\n     * Currently used for scroll animations.\n     */\n    attachTimeline(timeline) {\n        if (!this._resolved) {\n            this.pendingTimeline = timeline;\n        }\n        else {\n            const { resolved } = this;\n            if (!resolved)\n                return noop;\n            const { animation } = resolved;\n            attachTimeline(animation, timeline);\n        }\n        return noop;\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        if (animation.playState === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        animation.play();\n    }\n    pause() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.pause();\n    }\n    stop() {\n        this.resolver.cancel();\n        this.isStopped = true;\n        if (this.state === \"idle\")\n            return;\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation, keyframes, duration, type, ease, times } = resolved;\n        if (animation.playState === \"idle\" ||\n            animation.playState === \"finished\") {\n            return;\n        }\n        /**\n         * WAAPI doesn't natively have any interruption capabilities.\n         *\n         * Rather than read commited styles back out of the DOM, we can\n         * create a renderless JS animation and sample it twice to calculate\n         * its current value, \"previous\" value, and therefore allow\n         * Motion to calculate velocity for any subsequent animation.\n         */\n        if (this.time) {\n            const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n            const sampleAnimation = new MainThreadAnimation({\n                ...options,\n                keyframes,\n                duration,\n                type,\n                ease,\n                times,\n                isGenerator: true,\n            });\n            const sampleTime = secondsToMilliseconds(this.time);\n            motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);\n        }\n        const { onStop } = this.options;\n        onStop && onStop();\n        this.cancel();\n    }\n    complete() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.finish();\n    }\n    cancel() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.cancel();\n    }\n    static supports(options) {\n        const { motionValue, name, repeatDelay, repeatType, damping, type } = options;\n        if (!motionValue ||\n            !motionValue.owner ||\n            !(motionValue.owner.current instanceof HTMLElement)) {\n            return false;\n        }\n        const { onUpdate, transformTemplate } = motionValue.owner.getProps();\n        return (supportsWaapi() &&\n            name &&\n            acceleratedValues.has(name) &&\n            /**\n             * If we're outputting values to onUpdate then we can't use WAAPI as there's\n             * no way to read the value from WAAPI every frame.\n             */\n            !onUpdate &&\n            !transformTemplate &&\n            !repeatDelay &&\n            repeatType !== \"mirror\" &&\n            damping !== 0 &&\n            type !== \"inertia\");\n    }\n}\n\nexport { AcceleratedAnimation };\n","import { complex } from '../../value/types/complex/index.mjs';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (value, name) => {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (name === \"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) || value === \"0\") && // 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 { isGenerator } from 'motion-dom';\nimport { warning } from 'motion-utils';\nimport { isAnimatable } from '../../utils/is-animatable.mjs';\n\nfunction hasKeyframesChanged(keyframes) {\n    const current = keyframes[0];\n    if (keyframes.length === 1)\n        return true;\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] !== current)\n            return true;\n    }\n}\nfunction canAnimate(keyframes, name, type, velocity) {\n    /**\n     * Check if we're able to animate between the start and end keyframes,\n     * and throw a warning if we're attempting to animate between one that's\n     * animatable and another that isn't.\n     */\n    const originKeyframe = keyframes[0];\n    if (originKeyframe === null)\n        return false;\n    /**\n     * These aren't traditionally animatable but we do support them.\n     * In future we could look into making this more generic or replacing\n     * this function with mix() === mixImmediate\n     */\n    if (name === \"display\" || name === \"visibility\")\n        return true;\n    const targetKeyframe = keyframes[keyframes.length - 1];\n    const isOriginAnimatable = isAnimatable(originKeyframe, name);\n    const isTargetAnimatable = isAnimatable(targetKeyframe, name);\n    warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from \"${originKeyframe}\" to \"${targetKeyframe}\". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \\`style\\` property.`);\n    // Always skip if any of these are true\n    if (!isOriginAnimatable || !isTargetAnimatable) {\n        return false;\n    }\n    return (hasKeyframesChanged(keyframes) ||\n        ((type === \"spring\" || isGenerator(type)) && velocity));\n}\n\nexport { canAnimate };\n","import { time } from '../../frameloop/sync-time.mjs';\nimport { flushKeyframeResolvers } from '../../render/utils/KeyframesResolver.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\n/**\n * Maximum time allowed between an animation being created and it being\n * resolved for us to use the latter as the start time.\n *\n * This is to ensure that while we prefer to \"start\" an animation as soon\n * as it's triggered, we also want to avoid a visual jump if there's a big delay\n * between these two moments.\n */\nconst MAX_RESOLVE_DELAY = 40;\nclass BaseAnimation {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", ...options }) {\n        // Track whether the animation has been stopped. Stopped animations won't restart.\n        this.isStopped = false;\n        this.hasAttemptedResolve = false;\n        this.createdAt = time.now();\n        this.options = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            ...options,\n        };\n        this.updateFinishedPromise();\n    }\n    /**\n     * This method uses the createdAt and resolvedAt to calculate the\n     * animation startTime. *Ideally*, we would use the createdAt time as t=0\n     * as the following frame would then be the first frame of the animation in\n     * progress, which would feel snappier.\n     *\n     * However, if there's a delay (main thread work) between the creation of\n     * the animation and the first commited frame, we prefer to use resolvedAt\n     * to avoid a sudden jump into the animation.\n     */\n    calcStartTime() {\n        if (!this.resolvedAt)\n            return this.createdAt;\n        return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY\n            ? this.resolvedAt\n            : this.createdAt;\n    }\n    /**\n     * A getter for resolved data. If keyframes are not yet resolved, accessing\n     * this.resolved will synchronously flush all pending keyframe resolvers.\n     * This is a deoptimisation, but at its worst still batches read/writes.\n     */\n    get resolved() {\n        if (!this._resolved && !this.hasAttemptedResolve) {\n            flushKeyframeResolvers();\n        }\n        return this._resolved;\n    }\n    /**\n     * A method to be called when the keyframes resolver completes. This method\n     * will check if its possible to run the animation and, if not, skip it.\n     * Otherwise, it will call initPlayback on the implementing class.\n     */\n    onKeyframesResolved(keyframes, finalKeyframe) {\n        this.resolvedAt = time.now();\n        this.hasAttemptedResolve = true;\n        const { name, type, velocity, delay, onComplete, onUpdate, isGenerator, } = this.options;\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {\n            // Finish immediately\n            if (instantAnimationState.current || !delay) {\n                onUpdate &&\n                    onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.resolveFinishedPromise();\n                return;\n            }\n            // Finish after a delay\n            else {\n                this.options.duration = 0;\n            }\n        }\n        const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);\n        if (resolvedAnimation === false)\n            return;\n        this._resolved = {\n            keyframes,\n            finalKeyframe,\n            ...resolvedAnimation,\n        };\n        this.onPostResolved();\n    }\n    onPostResolved() { }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.currentFinishedPromise.then(resolve, reject);\n    }\n    flatten() {\n        this.options.type = \"keyframes\";\n        this.options.ease = \"linear\";\n    }\n    updateFinishedPromise() {\n        this.currentFinishedPromise = new Promise((resolve) => {\n            this.resolveFinishedPromise = resolve;\n        });\n    }\n}\n\nexport { BaseAnimation };\n","import { time } from '../../../frameloop/sync-time.mjs';\nimport { frame, cancelFrame, frameData } from '../../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: () => frame.update(passTimestamp, true),\n        stop: () => cancelFrame(passTimestamp),\n        /**\n         * If we're processing this frame we can use the\n         * framelocked timestamp to keep things in sync.\n         */\n        now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),\n    };\n};\n\nexport { frameloopDriver };\n","import { isGenerator, calcGeneratorDuration } from 'motion-dom';\nimport { invariant, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { KeyframeResolver } from '../../render/utils/KeyframesResolver.mjs';\nimport { activeAnimations } from '../../stats/animation-count.mjs';\nimport { clamp } from '../../utils/clamp.mjs';\nimport { mix } from '../../utils/mix/index.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { inertia } from '../generators/inertia.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { spring } from '../generators/spring/index.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { frameloopDriver } from './drivers/driver-frameloop.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\nconst generators = {\n    decay: inertia,\n    inertia,\n    tween: keyframes,\n    keyframes: keyframes,\n    spring,\n};\nconst percentToProgress = (percent) => percent / 100;\n/**\n * Animation that runs on the main thread. Designed to be WAAPI-spec in the subset of\n * features we expose publically. Mostly the compatibility is to ensure visual identity\n * between both WAAPI and main thread animations.\n */\nclass MainThreadAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * The time at which the animation was cancelled.\n         */\n        this.cancelTime = null;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * The state of the animation to apply when the animation is resolved. This\n         * allows calls to the public API to control the animation before it is resolved,\n         * without us having to resolve it first.\n         */\n        this.pendingPlayState = \"running\";\n        /**\n         * The time at which the animation was started.\n         */\n        this.startTime = null;\n        this.state = \"idle\";\n        /**\n         * This method is bound to the instance to fix a pattern where\n         * animation.stop is returned as a reference from a useEffect.\n         */\n        this.stop = () => {\n            this.resolver.cancel();\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            const { onStop } = this.options;\n            onStop && onStop();\n        };\n        const { name, motionValue, element, keyframes } = this.options;\n        const KeyframeResolver$1 = (element === null || element === void 0 ? void 0 : element.KeyframeResolver) || KeyframeResolver;\n        const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);\n        this.resolver = new KeyframeResolver$1(keyframes, onResolved, name, motionValue, element);\n        this.resolver.scheduleResolve();\n    }\n    flatten() {\n        super.flatten();\n        // If we've already resolved the animation, re-initialise it\n        if (this._resolved) {\n            Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));\n        }\n    }\n    initPlayback(keyframes$1) {\n        const { type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = this.options;\n        const generatorFactory = isGenerator(type)\n            ? type\n            : generators[type] || keyframes;\n        /**\n         * If our generator doesn't support mixing numbers, we need to replace keyframes with\n         * [0, 100] and then make a function that maps that to the actual keyframes.\n         *\n         * 100 is chosen instead of 1 as it works nicer with spring animations.\n         */\n        let mapPercentToKeyframes;\n        let mirroredGenerator;\n        if (process.env.NODE_ENV !== \"production\" &&\n            generatorFactory !== keyframes) {\n            invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n        }\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });\n        /**\n         * If we have a mirror repeat type we need to create a second generator that outputs the\n         * mirrored (not reversed) animation and later ping pong between the two generators.\n         */\n        if (repeatType === \"mirror\") {\n            mirroredGenerator = generatorFactory({\n                ...this.options,\n                keyframes: [...keyframes$1].reverse(),\n                velocity: -velocity,\n            });\n        }\n        /**\n         * If duration is undefined and we have repeat options,\n         * we need to calculate a duration from the generator.\n         *\n         * We set it to the generator itself to cache the duration.\n         * Any timeline resolver will need to have already precalculated\n         * the duration by this step.\n         */\n        if (generator.calculatedDuration === null) {\n            generator.calculatedDuration = calcGeneratorDuration(generator);\n        }\n        const { calculatedDuration } = generator;\n        const resolvedDuration = calculatedDuration + repeatDelay;\n        const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n        return {\n            generator,\n            mirroredGenerator,\n            mapPercentToKeyframes,\n            calculatedDuration,\n            resolvedDuration,\n            totalDuration,\n        };\n    }\n    onPostResolved() {\n        const { autoplay = true } = this.options;\n        activeAnimations.mainThread++;\n        this.play();\n        if (this.pendingPlayState === \"paused\" || !autoplay) {\n            this.pause();\n        }\n        else {\n            this.state = this.pendingPlayState;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { resolved } = this;\n        // If the animations has failed to resolve, return the final keyframe.\n        if (!resolved) {\n            const { keyframes } = this.options;\n            return { done: true, value: keyframes[keyframes.length - 1] };\n        }\n        const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes, calculatedDuration, totalDuration, resolvedDuration, } = resolved;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay, repeat, repeatType, repeatDelay, onUpdate } = this.options;\n        /**\n         * requestAnimationFrame timestamps can come through as lower than\n         * the startTime as set by performance.now(). Here we prevent this,\n         * though in the future it could be possible to make setting startTime\n         * a pending operation that gets resolved here.\n         */\n        if (this.speed > 0) {\n            this.startTime = Math.min(this.startTime, timestamp);\n        }\n        else if (this.speed < 0) {\n            this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);\n        }\n        // Update currentTime\n        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else if (this.holdTime !== null) {\n            this.currentTime = this.holdTime;\n        }\n        else {\n            // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n            // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n            // example.\n            this.currentTime =\n                Math.round(timestamp - this.startTime) * this.speed;\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.speed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.speed >= 0\n            ? timeWithoutDelay < 0\n            : timeWithoutDelay > totalDuration;\n        this.currentTime = Math.max(timeWithoutDelay, 0);\n        // If this animation has finished, set the current time  to the total duration.\n        if (this.state === \"finished\" && this.holdTime === null) {\n            this.currentTime = totalDuration;\n        }\n        let elapsed = this.currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        const state = isInDelayPhase\n            ? { done: false, value: keyframes[0] }\n            : frameGenerator.next(elapsed);\n        if (mapPercentToKeyframes) {\n            state.value = mapPercentToKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.speed >= 0\n                    ? this.currentTime >= totalDuration\n                    : this.currentTime <= 0;\n        }\n        const isAnimationFinished = this.holdTime === null &&\n            (this.state === \"finished\" || (this.state === \"running\" && done));\n        if (isAnimationFinished && finalKeyframe !== undefined) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\n    get duration() {\n        const { resolved } = this;\n        return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;\n    }\n    get time() {\n        return millisecondsToSeconds(this.currentTime);\n    }\n    set time(newTime) {\n        newTime = secondsToMilliseconds(newTime);\n        this.currentTime = newTime;\n        if (this.holdTime !== null || this.speed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.speed;\n        }\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        this.playbackSpeed = newSpeed;\n        if (hasChanged) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (!this.resolver.isScheduled) {\n            this.resolver.resume();\n        }\n        if (!this._resolved) {\n            this.pendingPlayState = \"running\";\n            return;\n        }\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, onPlay, startTime } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        onPlay && onPlay();\n        const now = this.driver.now();\n        if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();\n        }\n        else if (this.state === \"finished\") {\n            this.startTime = now;\n        }\n        if (this.state === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        this.cancelTime = this.startTime;\n        this.holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        this.state = \"running\";\n        this.driver.start();\n    }\n    pause() {\n        var _a;\n        if (!this._resolved) {\n            this.pendingPlayState = \"paused\";\n            return;\n        }\n        this.state = \"paused\";\n        this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.pendingPlayState = this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.teardown();\n        this.state = \"finished\";\n        const { onComplete } = this.options;\n        onComplete && onComplete();\n    }\n    cancel() {\n        if (this.cancelTime !== null) {\n            this.tick(this.cancelTime);\n        }\n        this.teardown();\n        this.updateFinishedPromise();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        this.startTime = this.cancelTime = null;\n        this.resolver.cancel();\n        activeAnimations.mainThread--;\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(time) {\n        this.startTime = 0;\n        return this.tick(time, true);\n    }\n}\n// Legacy interface\nfunction animateValue(options) {\n    return new MainThreadAnimation(options);\n}\n\nexport { MainThreadAnimation, animateValue };\n","/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\n    \"opacity\",\n    \"clipPath\",\n    \"filter\",\n    \"transform\",\n    // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved\n    // or until we implement support for linear() easing.\n    // \"background-color\"\n]);\n\nexport { acceleratedValues };\n","import { mapEasingToNativeEasing } from 'motion-dom';\nimport { activeAnimations } from '../../../stats/animation-count.mjs';\nimport { statsBuffer } from '../../../stats/buffer.mjs';\n\nfunction startWaapiAnimation(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = \"loop\", ease = \"easeInOut\", times, } = {}) {\n    const keyframeOptions = { [valueName]: keyframes };\n    if (times)\n        keyframeOptions.offset = times;\n    const easing = mapEasingToNativeEasing(ease, duration);\n    /**\n     * If this is an easing array, apply to keyframes, not animation as a whole\n     */\n    if (Array.isArray(easing))\n        keyframeOptions.easing = easing;\n    if (statsBuffer.value) {\n        activeAnimations.waapi++;\n    }\n    const animation = element.animate(keyframeOptions, {\n        delay,\n        duration,\n        easing: !Array.isArray(easing) ? easing : \"linear\",\n        fill: \"both\",\n        iterations: repeat + 1,\n        direction: repeatType === \"reverse\" ? \"alternate\" : \"normal\",\n    });\n    if (statsBuffer.value) {\n        animation.finished.finally(() => {\n            activeAnimations.waapi--;\n        });\n    }\n    return animation;\n}\n\nexport { startWaapiAnimation };\n","const isNotNull = (value) => value !== null;\nfunction getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }, finalKeyframe) {\n    const resolvedKeyframes = keyframes.filter(isNotNull);\n    const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1\n        ? 0\n        : resolvedKeyframes.length - 1;\n    return !index || finalKeyframe === undefined\n        ? resolvedKeyframes[index]\n        : finalKeyframe;\n}\n\nexport { getFinalKeyframe };\n","import { memo } from 'motion-utils';\n\nconst supportsWaapi = /*@__PURE__*/ memo(() => Object.hasOwnProperty.call(Element.prototype, \"animate\"));\n\nexport { supportsWaapi };\n","import { spring } from './spring/index.mjs';\nimport { calcGeneratorVelocity } from './utils/velocity.mjs';\n\nfunction inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {\n    const origin = keyframes[0];\n    const state = {\n        done: false,\n        value: origin,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (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    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);\n    const calcLatest = (t) => target + calcDelta(t);\n    const applyFriction = (t) => {\n        const delta = calcDelta(t);\n        const latest = calcLatest(t);\n        state.done = Math.abs(delta) <= restDelta;\n        state.value = state.done ? target : latest;\n    };\n    /**\n     * Ideally this would resolve for t in a stateless way, we could\n     * do that by always precalculating the animation but as we know\n     * this will be done anyway we can assume that spring will\n     * be discovered during that.\n     */\n    let timeReachedBoundary;\n    let spring$1;\n    const checkCatchBoundary = (t) => {\n        if (!isOutOfBounds(state.value))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            keyframes: [state.value, nearestBoundary(state.value)],\n            velocity: calcGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDelta,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return {\n        calculatedDuration: null,\n        next: (t) => {\n            /**\n             * We need to resolve the friction to figure out if we need a\n             * spring but we don't want to do this twice per frame. So here\n             * we flag if we updated for this frame and later if we did\n             * we can skip doing it again.\n             */\n            let hasUpdatedFrame = false;\n            if (!spring$1 && timeReachedBoundary === undefined) {\n                hasUpdatedFrame = true;\n                applyFriction(t);\n                checkCatchBoundary(t);\n            }\n            /**\n             * If we have a spring and the provided t is beyond the moment the friction\n             * animation crossed the min/max boundary, use the spring.\n             */\n            if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {\n                return spring$1.next(t - timeReachedBoundary);\n            }\n            else {\n                !hasUpdatedFrame && applyFriction(t);\n                return state;\n            }\n        },\n    };\n}\n\nexport { inertia };\n","function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n","import { easeInOut } from '../../easing/ease.mjs';\nimport { isEasingArray } from '../../easing/utils/is-easing-array.mjs';\nimport { easingDefinitionToFunction } from '../../easing/utils/map.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../../utils/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n","const springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\n\nexport { springDefaults };\n","import { warning, secondsToMilliseconds, millisecondsToSeconds } from 'motion-utils';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { springDefaults } from './defaults.mjs';\n\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\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 };\n","import { calcGeneratorDuration, maxGeneratorDuration, generateLinearEasing } from 'motion-dom';\nimport { millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.mjs';\nimport { springDefaults } from './defaults.mjs';\nimport { findSpring, calcAngularFreq } from './find.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring(options);\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = 0.0;\n                /**\n                 * We only need to calculate velocity for under-damped springs\n                 * as over- and critically-damped springs can't overshoot, so\n                 * checking only for displacement is enough.\n                 */\n                if (dampingRatio < 1) {\n                    currentVelocity =\n                        t === 0\n                            ? secondsToMilliseconds(initialVelocity)\n                            : calcGeneratorVelocity(resolveSpring, t, current);\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n    };\n    return generator;\n}\n\nexport { spring };\n","import { velocityPerSecond } from '../../../utils/velocity-per-second.mjs';\n\nconst velocitySampleDuration = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { calcGeneratorVelocity };\n","import { transformProps } from '../../render/html/utils/keys-transform.mjs';\n\nconst underDampedSpring = {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n};\nconst criticallyDampedSpring = (target) => ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: target === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n});\nconst keyframesTransition = {\n    type: \"keyframes\",\n    duration: 0.8,\n};\n/**\n * Default easing curve is a slightly shallower version of\n * the default browser easing curve.\n */\nconst ease = {\n    type: \"keyframes\",\n    ease: [0.25, 0.1, 0.35, 1],\n    duration: 0.3,\n};\nconst getDefaultTransition = (valueKey, { keyframes }) => {\n    if (keyframes.length > 2) {\n        return keyframesTransition;\n    }\n    else if (transformProps.has(valueKey)) {\n        return valueKey.startsWith(\"scale\")\n            ? criticallyDampedSpring(keyframes[1])\n            : underDampedSpring;\n    }\n    return ease;\n};\n\nexport { getDefaultTransition };\n","/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {\n    return !!Object.keys(transition).length;\n}\n\nexport { isTransitionDefined };\n","import { getValueTransition, GroupPlaybackControls } from 'motion-dom';\nimport { secondsToMilliseconds } from 'motion-utils';\nimport { frame } from '../../frameloop/frame.mjs';\nimport { MotionGlobalConfig } from '../../utils/GlobalConfig.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { AcceleratedAnimation } from '../animators/AcceleratedAnimation.mjs';\nimport { MainThreadAnimation } from '../animators/MainThreadAnimation.mjs';\nimport { getFinalKeyframe } from '../animators/waapi/utils/get-final-keyframe.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    let options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unqiue transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        options = {\n            ...options,\n            ...getDefaultTransition(name, options),\n        };\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    if (options.duration) {\n        options.duration = secondsToMilliseconds(options.duration);\n    }\n    if (options.repeatDelay) {\n        options.repeatDelay = secondsToMilliseconds(options.repeatDelay);\n    }\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        options.duration = 0;\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (instantAnimationState.current ||\n        MotionGlobalConfig.skipAnimations) {\n        shouldSkip = true;\n        options.duration = 0;\n        options.delay = 0;\n    }\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            // We still want to return some animation controls here rather\n            // than returning undefined\n            return new GroupPlaybackControls([]);\n        }\n    }\n    /**\n     * Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via\n     * WAAPI. Therefore, this animation must be JS to ensure it runs \"under\" the\n     * optimised animation.\n     */\n    if (!isHandoff && AcceleratedAnimation.supports(options)) {\n        return new AcceleratedAnimation(options);\n    }\n    else {\n        return new MainThreadAnimation(options);\n    }\n};\n\nexport { animateMotionValue };\n","import { getValueTransition } from 'motion-dom';\nimport { positionalKeys } from '../../render/html/utils/keys-position.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { addValueToWillChange } from '../../value/use-will-change/add-will-change.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\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}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    var _a;\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    for (const key in target) {\n        const value = visualElement.getValue(key, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            ...getValueTransition(transition || {}, key),\n        };\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.MotionHandoffAnimation) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const startTime = window.MotionHandoffAnimation(appearId, key, frame);\n                if (startTime !== null) {\n                    valueTransition.startTime = startTime;\n                    isHandoff = true;\n                }\n            }\n        }\n        addValueToWillChange(visualElement, key);\n        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && positionalKeys.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff));\n        const animation = value.animation;\n        if (animation) {\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        Promise.all(animations).then(() => {\n            frame.update(() => {\n                transitionEnd && setTarget(visualElement, transitionEnd);\n            });\n        });\n    }\n    return animations;\n}\n\nexport { animateTarget };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    var _a;\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n        : undefined);\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        ? () => Promise.all(animateTarget(visualElement, resolved, options))\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n\nexport { animateVariant, sortByTreeOrder };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\nimport { animateVariant } from './visual-element-variant.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 = Promise.all(animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => {\n        visualElement.notify(\"AnimationComplete\", definition);\n    });\n}\n\nexport { animateVisualElement };\n","import { optimizedAppearDataAttribute } from './data-id.mjs';\n\nfunction getOptimisedAppearId(visualElement) {\n    return visualElement.props[optimizedAppearDataAttribute];\n}\n\nexport { getOptimisedAppearId };\n","import { backIn } from './back.mjs';\n\nconst anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n\nexport { anticipate };\n","import { cubicBezier } from './cubic-bezier.mjs';\nimport { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst backOut = /*@__PURE__*/ cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = /*@__PURE__*/ reverseEasing(backOut);\nconst backInOut = /*@__PURE__*/ mirrorEasing(backIn);\n\nexport { backIn, backInOut, backOut };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst circIn = (p) => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circIn);\n\nexport { circIn, circInOut, circOut };\n","import { noop } from 'motion-utils';\n\n/*\n  Bezier function generator\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *\n    t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noop;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { cubicBezier } from './cubic-bezier.mjs';\n\nconst easeIn = /*@__PURE__*/ cubicBezier(0.42, 0, 1, 1);\nconst easeOut = /*@__PURE__*/ cubicBezier(0, 0, 0.58, 1);\nconst easeInOut = /*@__PURE__*/ cubicBezier(0.42, 0, 0.58, 1);\n\nexport { easeIn, easeInOut, easeOut };\n","// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\nexport { mirrorEasing };\n","// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = (easing) => (p) => 1 - easing(1 - p);\n\nexport { reverseEasing };\n","const isEasingArray = (ease) => {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { isEasingArray };\n","import { isBezierDefinition } from 'motion-dom';\nimport { invariant, noop } from 'motion-utils';\nimport { anticipate } from '../anticipate.mjs';\nimport { backIn, backInOut, backOut } from '../back.mjs';\nimport { circIn, circInOut, circOut } from '../circ.mjs';\nimport { cubicBezier } from '../cubic-bezier.mjs';\nimport { easeIn, easeInOut, easeOut } from '../ease.mjs';\n\nconst easingLookup = {\n    linear: noop,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n};\nconst easingDefinitionToFunction = (definition) => {\n    if (isBezierDefinition(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};\n\nexport { easingDefinitionToFunction };\n","function addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n\nexport { addDomEvent };\n","import { isPrimaryPointer } from 'motion-dom';\n\nfunction extractEventInfo(event) {\n    return {\n        point: {\n            x: event.pageX,\n            y: event.pageY,\n        },\n    };\n}\nconst addPointerInfo = (handler) => {\n    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));\n};\n\nexport { addPointerInfo, extractEventInfo };\n","import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';\nimport { frameData } from './frame.mjs';\n\nlet now;\nfunction clearTime() {\n    now = undefined;\n}\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\nconst time = {\n    now: () => {\n        if (now === undefined) {\n            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming\n                ? frameData.timestamp\n                : performance.now());\n        }\n        return now;\n    },\n    set: (newTime) => {\n        now = newTime;\n        queueMicrotask(clearTime);\n    },\n};\n\nexport { time };\n","class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\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 { isVariantLabel } from './is-variant-label.mjs';\nimport { variantProps } from './variant-props.mjs';\n\nconst numVariantProps = variantProps.length;\nfunction getVariantContext(visualElement) {\n    if (!visualElement)\n        return undefined;\n    if (!visualElement.isControllingVariants) {\n        const context = visualElement.parent\n            ? getVariantContext(visualElement.parent) || {}\n            : {};\n        if (visualElement.props.initial !== undefined) {\n            context.initial = visualElement.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 = visualElement.props[name];\n        if (isVariantLabel(prop) || prop === false) {\n            context[name] = prop;\n        }\n    }\n    return context;\n}\n\nexport { getVariantContext };\n","import { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { getVariantContext } from './get-variant-context.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    let 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 = (type) => (acc, definition) => {\n        var _a;\n        const resolved = resolveVariant(visualElement, definition, type === \"exit\"\n            ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n            : undefined);\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(changedActiveType) {\n        const { props } = visualElement;\n        const context = getVariantContext(visualElement.parent) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined\n                ? props[type]\n                : 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] &&\n                prop !== props[type] &&\n                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            let handledRemovedValues = false;\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(type), {});\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                if (removedKeys.has(key)) {\n                    handledRemovedValues = true;\n                    removedKeys.delete(key);\n                }\n                typeState.needsAnimating[key] = true;\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = false;\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                let valueHasChanged = false;\n                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                    valueHasChanged = !shallowCompare(next, prev);\n                }\n                else {\n                    valueHasChanged = next !== prev;\n                }\n                if (valueHasChanged) {\n                    if (next !== undefined && next !== null) {\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 skip this animation\n             * unless the inherited variants haven't changed on this render.\n             */\n            const willAnimateViaParent = isInherited && variantDidChange;\n            const needsAnimating = !willAnimateViaParent || handledRemovedValues;\n            if (shouldAnimateType && needsAnimating) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type },\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            /**\n             * If the initial prop contains a transition we can use that, otherwise\n             * allow the animation function to use the visual element's default.\n             */\n            if (typeof props.initial !== \"boolean\") {\n                const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial)\n                    ? props.initial[0]\n                    : props.initial);\n                if (initialTransition && initialTransition.transition) {\n                    fallbackAnimation.transition = initialTransition.transition;\n                }\n            }\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = true;\n                // @ts-expect-error - @mattgperry to figure if we should do something here\n                fallbackAnimation[key] = fallbackTarget !== null && fallbackTarget !== void 0 ? fallbackTarget : null;\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            (props.initial === false || props.initial === props.animate) &&\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) {\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(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        reset: () => {\n            state = createState();\n            isInitialRender = true;\n        },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n","import { isAnimationControls } from '../../../animation/utils/is-animation-controls.mjs';\nimport { createAnimationState } from '../../../render/utils/animation-state.mjs';\nimport { Feature } from '../Feature.mjs';\n\nclass AnimationFeature extends Feature {\n    /**\n     * We dynamically generate the AnimationState manager as it contains a reference\n     * to the underlying animation library. We only want to load that if we load this,\n     * so people can optionally code split it out using the `m` component.\n     */\n    constructor(node) {\n        super(node);\n        node.animationState || (node.animationState = createAnimationState(node));\n    }\n    updateAnimationControlsSubscription() {\n        const { animate } = this.node.getProps();\n        if (isAnimationControls(animate)) {\n            this.unmountControls = animate.subscribe(this.node);\n        }\n    }\n    /**\n     * Subscribe any provided AnimationControls to the component's VisualElement\n     */\n    mount() {\n        this.updateAnimationControlsSubscription();\n    }\n    update() {\n        const { animate } = this.node.getProps();\n        const { animate: prevAnimate } = this.node.prevProps || {};\n        if (animate !== prevAnimate) {\n            this.updateAnimationControlsSubscription();\n        }\n    }\n    unmount() {\n        var _a;\n        this.node.animationState.reset();\n        (_a = this.unmountControls) === null || _a === void 0 ? void 0 : _a.call(this);\n    }\n}\n\nexport { AnimationFeature };\n","import { Feature } from '../Feature.mjs';\n\nlet id = 0;\nclass ExitAnimationFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.id = id++;\n    }\n    update() {\n        if (!this.node.presenceContext)\n            return;\n        const { isPresent, onExitComplete } = this.node.presenceContext;\n        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};\n        if (!this.node.animationState || isPresent === prevIsPresent) {\n            return;\n        }\n        const exitAnimation = this.node.animationState.setActive(\"exit\", !isPresent);\n        if (onExitComplete && !isPresent) {\n            exitAnimation.then(() => {\n                onExitComplete(this.id);\n            });\n        }\n    }\n    mount() {\n        const { register, onExitComplete } = this.node.presenceContext || {};\n        if (onExitComplete) {\n            onExitComplete(this.id);\n        }\n        if (register) {\n            this.unmount = register(this.id);\n        }\n    }\n    unmount() { }\n}\n\nexport { ExitAnimationFeature };\n","import { AnimationFeature } from './animation/index.mjs';\nimport { ExitAnimationFeature } from './animation/exit.mjs';\n\nconst animations = {\n    animation: {\n        Feature: AnimationFeature,\n    },\n    exit: {\n        Feature: ExitAnimationFeature,\n    },\n};\n\nexport { animations };\n","import { hover } from 'motion-dom';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction handleHoverEvent(node, event, lifecycle) {\n    const { props } = node;\n    if (node.animationState && props.whileHover) {\n        node.animationState.setActive(\"whileHover\", lifecycle === \"Start\");\n    }\n    const eventName = (\"onHover\" + lifecycle);\n    const callback = props[eventName];\n    if (callback) {\n        frame.postRender(() => callback(event, extractEventInfo(event)));\n    }\n}\nclass HoverGesture extends Feature {\n    mount() {\n        const { current } = this.node;\n        if (!current)\n            return;\n        this.unmount = hover(current, (_element, startEvent) => {\n            handleHoverEvent(this.node, startEvent, \"Start\");\n            return (endEvent) => handleHoverEvent(this.node, endEvent, \"End\");\n        });\n    }\n    unmount() { }\n}\n\nexport { HoverGesture };\n","import { addDomEvent } from '../events/add-dom-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\n\nclass FocusGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.isActive = false;\n    }\n    onFocus() {\n        let isFocusVisible = false;\n        /**\n         * If this element doesn't match focus-visible then don't\n         * apply whileHover. But, if matches throws that focus-visible\n         * is not a valid selector then in that browser outline styles will be applied\n         * to the element by default and we want to match that behaviour with whileFocus.\n         */\n        try {\n            isFocusVisible = this.node.current.matches(\":focus-visible\");\n        }\n        catch (e) {\n            isFocusVisible = true;\n        }\n        if (!isFocusVisible || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", true);\n        this.isActive = true;\n    }\n    onBlur() {\n        if (!this.isActive || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", false);\n        this.isActive = false;\n    }\n    mount() {\n        this.unmount = pipe(addDomEvent(this.node.current, \"focus\", () => this.onFocus()), addDomEvent(this.node.current, \"blur\", () => this.onBlur()));\n    }\n    unmount() { }\n}\n\nexport { FocusGesture };\n","import { press } from 'motion-dom';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction handlePressEvent(node, event, lifecycle) {\n    const { props } = node;\n    if (node.current instanceof HTMLButtonElement && node.current.disabled) {\n        return;\n    }\n    if (node.animationState && props.whileTap) {\n        node.animationState.setActive(\"whileTap\", lifecycle === \"Start\");\n    }\n    const eventName = (\"onTap\" + (lifecycle === \"End\" ? \"\" : lifecycle));\n    const callback = props[eventName];\n    if (callback) {\n        frame.postRender(() => callback(event, extractEventInfo(event)));\n    }\n}\nclass PressGesture extends Feature {\n    mount() {\n        const { current } = this.node;\n        if (!current)\n            return;\n        this.unmount = press(current, (_element, startEvent) => {\n            handlePressEvent(this.node, startEvent, \"Start\");\n            return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? \"End\" : \"Cancel\");\n        }, { useGlobalTarget: this.node.props.globalTapTarget });\n    }\n    unmount() { }\n}\n\nexport { PressGesture };\n","/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nconst observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nconst observers = new WeakMap();\nconst fireObserverCallback = (entry) => {\n    const callback = observerCallbacks.get(entry.target);\n    callback && callback(entry);\n};\nconst fireAllObserverCallbacks = (entries) => {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver({ root, ...options }) {\n    const lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    const rootObservers = observers.get(lookupRoot);\n    const key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    const rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return () => {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { Feature } from '../Feature.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nclass InViewFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n    startObserver() {\n        this.unmount();\n        const { viewport = {} } = this.node.getProps();\n        const { root, margin: rootMargin, amount = \"some\", once } = viewport;\n        const options = {\n            root: root ? root.current : undefined,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const onIntersectionUpdate = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (this.isInView === isIntersecting)\n                return;\n            this.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && this.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                this.hasEnteredView = true;\n            }\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const { onViewportEnter, onViewportLeave } = this.node.getProps();\n            const callback = isIntersecting ? onViewportEnter : onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(this.node.current, options, onIntersectionUpdate);\n    }\n    mount() {\n        this.startObserver();\n    }\n    update() {\n        if (typeof IntersectionObserver === \"undefined\")\n            return;\n        const { props, prevProps } = this.node;\n        const hasOptionsChanged = [\"amount\", \"margin\", \"root\"].some(hasViewportOptionChanged(props, prevProps));\n        if (hasOptionsChanged) {\n            this.startObserver();\n        }\n    }\n    unmount() { }\n}\nfunction hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {\n    return (name) => viewport[name] !== prevViewport[name];\n}\n\nexport { InViewFeature };\n","import { HoverGesture } from '../../gestures/hover.mjs';\nimport { FocusGesture } from '../../gestures/focus.mjs';\nimport { PressGesture } from '../../gestures/press.mjs';\nimport { InViewFeature } from './viewport/index.mjs';\n\nconst gestureAnimations = {\n    inView: {\n        Feature: InViewFeature,\n    },\n    tap: {\n        Feature: PressGesture,\n    },\n    focus: {\n        Feature: FocusGesture,\n    },\n    hover: {\n        Feature: HoverGesture,\n    },\n};\n\nexport { gestureAnimations };\n","/**\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 { mixNumber } from '../../utils/mix/number.mjs';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    const distanceFromOrigin = point - originPoint;\n    const scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, { x, y }) {\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\nconst TREE_SCALE_SNAP_MIN = 0.999999999999;\nconst TREE_SCALE_SNAP_MAX = 1.0000000000001;\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {\n    const treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    let node;\n    let delta;\n    for (let i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        /**\n         * TODO: Prefer to remove this, but currently we have motion components with\n         * display: contents in Framer.\n         */\n        const { visualElement } = node.options;\n        if (visualElement &&\n            visualElement.props.style &&\n            visualElement.props.style.display === \"contents\") {\n            continue;\n        }\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, {\n                x: -node.scroll.offset.x,\n                y: -node.scroll.offset.y,\n            });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n    /**\n     * Snap tree scale back to 1 if it's within a non-perceivable threshold.\n     * This will help reduce useless scales getting rendered.\n     */\n    if (treeScale.x < TREE_SCALE_SNAP_MAX &&\n        treeScale.x > TREE_SCALE_SNAP_MIN) {\n        treeScale.x = 1.0;\n    }\n    if (treeScale.y < TREE_SCALE_SNAP_MAX &&\n        treeScale.y > TREE_SCALE_SNAP_MIN) {\n        treeScale.y = 1.0;\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, axisTranslate, axisScale, boxScale, axisOrigin = 0.5) {\n    const originPoint = mixNumber(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, axisTranslate, axisScale, originPoint, boxScale);\n}\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform.x, transform.scaleX, transform.scale, transform.originX);\n    transformAxis(box.y, transform.y, transform.scaleY, transform.scale, transform.originY);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","const createAxisDelta = () => ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n});\nconst createDelta = () => ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n});\nconst createAxis = () => ({ min: 0, max: 0 });\nconst createBox = () => ({\n    x: createAxis(),\n    y: createAxis(),\n});\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","function 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        values.skewX ||\n        values.skewY);\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 { color } from '../../../value/types/color/index.mjs';\nimport { complex } from '../../../value/types/complex/index.mjs';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = (v) => valueTypes.find(testValueType(v));\n\nexport { findValueType };\n","import { 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    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            /**\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 === \"12.4.10\", `Attempting to mix Motion versions ${nextValue.version} with 12.4.10 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n        }\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                if (existingValue.liveStyle === true) {\n                    existingValue.jump(nextValue);\n                }\n                else if (!existingValue.hasAnimated) {\n                    existingValue.set(nextValue);\n                }\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { time } from '../frameloop/sync-time.mjs';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isNumericalString } from '../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../utils/is-zero-value-string.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 { warnOnce } from '../utils/warn-once.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { complex } from '../value/types/complex/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { getAnimatableNone } from './dom/value-types/animatable-none.mjs';\nimport { findValueType } from './dom/value-types/find.mjs';\nimport { transformProps } from './html/utils/keys-transform.mjs';\nimport { visualElementStore } from './store.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { KeyframeResolver } from './utils/KeyframesResolver.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\nimport { frame, cancelFrame } from '../frameloop/frame.mjs';\n\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\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    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {\n        return {};\n    }\n    constructor({ parent, props, presenceContext, reducedMotionConfig, blockInitialAnimation, 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        this.KeyframeResolver = KeyframeResolver;\n        /**\n         * Cleanup functions for active features (hover/tap/exit etc)\n         */\n        this.features = {};\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.renderScheduledAt = 0.0;\n        this.scheduleRender = () => {\n            const now = time.now();\n            if (this.renderScheduledAt < now) {\n                this.renderScheduledAt = now;\n                frame.render(this.render, false, true);\n            }\n        };\n        const { latestValues, renderState, onUpdate } = visualState;\n        this.onUpdate = onUpdate;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.presenceContext = presenceContext;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.blockInitialAnimation = Boolean(blockInitialAnimation);\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 necessarily a breaking change,\n         * more a reflection of the test.\n         */\n        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);\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            }\n        }\n    }\n    mount(instance) {\n        this.current = instance;\n        visualElementStore.set(instance, this);\n        if (this.projection && !this.projection.instance) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = this.parent.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n        }\n        if (this.parent)\n            this.parent.children.add(this);\n        this.update(this.props, this.presenceContext);\n    }\n    unmount() {\n        this.projection && this.projection.unmount();\n        cancelFrame(this.notifyUpdate);\n        cancelFrame(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        this.valueSubscriptions.clear();\n        this.removeFromVariantTree && this.removeFromVariantTree();\n        this.parent && this.parent.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        for (const key in this.features) {\n            const feature = this.features[key];\n            if (feature) {\n                feature.unmount();\n                feature.isMounted = false;\n            }\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        if (this.valueSubscriptions.has(key)) {\n            this.valueSubscriptions.get(key)();\n        }\n        const valueIsTransform = transformProps.has(key);\n        if (valueIsTransform && this.onBindTransform) {\n            this.onBindTransform();\n        }\n        const removeOnChange = value.on(\"change\", (latestValue) => {\n            this.latestValues[key] = latestValue;\n            this.props.onUpdate && frame.preRender(this.notifyUpdate);\n            if (valueIsTransform && this.projection) {\n                this.projection.isTransformDirty = true;\n            }\n        });\n        const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n        let removeSyncCheck;\n        if (window.MotionCheckAppearSync) {\n            removeSyncCheck = window.MotionCheckAppearSync(this, key, value);\n        }\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n            if (removeSyncCheck)\n                removeSyncCheck();\n            if (value.owner)\n                value.stop();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type) {\n            return 0;\n        }\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    updateFeatures() {\n        let key = \"animation\";\n        for (key in featureDefinitions) {\n            const featureDefinition = featureDefinitions[key];\n            if (!featureDefinition)\n                continue;\n            const { isEnabled, Feature: FeatureConstructor } = featureDefinition;\n            /**\n             * If this feature is enabled but not active, make a new instance.\n             */\n            if (!this.features[key] &&\n                FeatureConstructor &&\n                isEnabled(this.props)) {\n                this.features[key] = new FeatureConstructor(this);\n            }\n            /**\n             * If we have a feature, mount or update it.\n             */\n            if (this.features[key]) {\n                const feature = this.features[key];\n                if (feature.isMounted) {\n                    feature.update();\n                }\n                else {\n                    feature.mount();\n                    feature.isMounted = true;\n                }\n            }\n        }\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, 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     * Update the provided props. Ensure any newly-added motion values are\n     * added to our map, old ones removed, and listeners updated.\n     */\n    update(props, presenceContext) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.prevProps = this.props;\n        this.props = props;\n        this.prevPresenceContext = this.presenceContext;\n        this.presenceContext = presenceContext;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listenerName = (\"on\" + key);\n            const listener = props[listenerName];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps, this), this.prevMotionValues);\n        if (this.handleChildMotionValue) {\n            this.handleChildMotionValue();\n        }\n        this.onUpdate && this.onUpdate(this);\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        return this.props.variants ? this.props.variants[name] : undefined;\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        return this.isVariantNode\n            ? this\n            : this.parent\n                ? this.parent.getClosestVariantNode()\n                : undefined;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            closestVariantNode.variantChildren &&\n                closestVariantNode.variantChildren.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        const existingValue = this.values.get(key);\n        if (value !== existingValue) {\n            if (existingValue)\n                this.removeValue(key);\n            this.bindToMotionValue(key, value);\n            this.values.set(key, value);\n            this.latestValues[key] = value.get();\n        }\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        this.values.delete(key);\n        const unsubscribe = this.valueSubscriptions.get(key);\n        if (unsubscribe) {\n            unsubscribe();\n            this.valueSubscriptions.delete(key);\n        }\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\n    getValue(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue === null ? undefined : defaultValue, { owner: this });\n            this.addValue(key, value);\n        }\n        return value;\n    }\n    /**\n     * If we're trying to animate to a previously unencountered value,\n     * we need to check for it in our state and as a last resort read it\n     * directly from the instance (which might have performance implications).\n     */\n    readValue(key, target) {\n        var _a;\n        let value = this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);\n        if (value !== undefined && value !== null) {\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(target)) {\n                value = getAnimatableNone(key, target);\n            }\n            this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);\n        }\n        return isMotionValue(value) ? value.get() : value;\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        let valueFromInitial;\n        if (typeof initial === \"string\" || typeof initial === \"object\") {\n            const variant = resolveVariantFromProps(this.props, initial, (_a = this.presenceContext) === null || _a === void 0 ? void 0 : _a.custom);\n            if (variant) {\n                valueFromInitial = variant[key];\n            }\n        }\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        if (this.events[eventName]) {\n            this.events[eventName].notify(...args);\n        }\n    }\n}\n\nexport { VisualElement };\n","import { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\n\nfunction isNone(value) {\n    if (typeof value === \"number\") {\n        return value === 0;\n    }\n    else if (value !== null) {\n        return value === \"none\" || value === \"0\" || isZeroValueString(value);\n    }\n    else {\n        return true;\n    }\n}\n\nexport { isNone };\n","import { analyseComplexValue } from '../../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../../dom/value-types/animatable-none.mjs';\n\n/**\n * If we encounter keyframes like \"none\" or \"0\" and we also have keyframes like\n * \"#fff\" or \"200px 200px\" we want to find a keyframe to serve as a template for\n * the \"none\" keyframes. In this case \"#fff\" or \"200px 200px\" - then these get turned into\n * zero equivalents, i.e. \"#fff0\" or \"0px 0px\".\n */\nconst invalidTemplates = new Set([\"auto\", \"none\", \"0\"]);\nfunction makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {\n    let i = 0;\n    let animatableTemplate = undefined;\n    while (i < unresolvedKeyframes.length && !animatableTemplate) {\n        const keyframe = unresolvedKeyframes[i];\n        if (typeof keyframe === \"string\" &&\n            !invalidTemplates.has(keyframe) &&\n            analyseComplexValue(keyframe).values.length) {\n            animatableTemplate = unresolvedKeyframes[i];\n        }\n        i++;\n    }\n    if (animatableTemplate && name) {\n        for (const noneIndex of noneKeyframeIndexes) {\n            unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);\n        }\n    }\n}\n\nexport { makeNoneKeyframesAnimatable };\n","import { invariant } from 'motion-utils';\nimport { isNumericalString } from '../../../utils/is-numerical-string.mjs';\nimport { isCSSVariableToken } from './is-css-variable.mjs';\n\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst splitCSSVariableRegex = \n// eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words\n/^var\\(--(?:([\\w-]+)|([\\w-]+), ?([a-zA-Z\\d ()%#.,-]+))\\)/u;\nfunction parseCSSVariable(current) {\n    const match = splitCSSVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token1, token2, fallback] = match;\n    return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, 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        const trimmed = resolved.trim();\n        return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;\n    }\n    return isCSSVariableToken(fallback)\n        ? getVariableValue(fallback, element, depth + 1)\n        : fallback;\n}\n\nexport { getVariableValue, parseCSSVariable };\n","import { isNone } from '../../animation/utils/is-none.mjs';\nimport { positionalKeys } from '../html/utils/keys-position.mjs';\nimport { makeNoneKeyframesAnimatable } from '../html/utils/make-none-animatable.mjs';\nimport { KeyframeResolver } from '../utils/KeyframesResolver.mjs';\nimport { getVariableValue } from './utils/css-variables-conversion.mjs';\nimport { isCSSVariableToken } from './utils/is-css-variable.mjs';\nimport { isNumOrPxType, positionalValues } from './utils/unit-conversion.mjs';\nimport { findDimensionValueType } from './value-types/dimensions.mjs';\n\nclass DOMKeyframesResolver extends KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {\n        super(unresolvedKeyframes, onComplete, name, motionValue, element, true);\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, element, name } = this;\n        if (!element || !element.current)\n            return;\n        super.readKeyframes();\n        /**\n         * If any keyframe is a CSS variable, we need to find its value by sampling the element\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            let keyframe = unresolvedKeyframes[i];\n            if (typeof keyframe === \"string\") {\n                keyframe = keyframe.trim();\n                if (isCSSVariableToken(keyframe)) {\n                    const resolved = getVariableValue(keyframe, element.current);\n                    if (resolved !== undefined) {\n                        unresolvedKeyframes[i] = resolved;\n                    }\n                    if (i === unresolvedKeyframes.length - 1) {\n                        this.finalKeyframe = keyframe;\n                    }\n                }\n            }\n        }\n        /**\n         * Resolve \"none\" values. We do this potentially twice - once before and once after measuring keyframes.\n         * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which\n         * have a far bigger performance impact.\n         */\n        this.resolveNoneKeyframes();\n        /**\n         * Check to see if unit type has changed. If so schedule jobs that will\n         * temporarily set styles to the destination keyframes.\n         * Skip if we have more than two keyframes or this isn't a positional value.\n         * TODO: We can throw if there are multiple keyframes and the value type changes.\n         */\n        if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {\n            return;\n        }\n        const [origin, target] = unresolvedKeyframes;\n        const originType = findDimensionValueType(origin);\n        const targetType = findDimensionValueType(target);\n        /**\n         * Either we don't recognise these value types or we can animate between them.\n         */\n        if (originType === targetType)\n            return;\n        /**\n         * If both values are numbers or pixels, we can animate between them by\n         * converting them to numbers.\n         */\n        if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {\n            for (let i = 0; i < unresolvedKeyframes.length; i++) {\n                const value = unresolvedKeyframes[i];\n                if (typeof value === \"string\") {\n                    unresolvedKeyframes[i] = parseFloat(value);\n                }\n            }\n        }\n        else {\n            /**\n             * Else, the only way to resolve this is by measuring the element.\n             */\n            this.needsMeasurement = true;\n        }\n    }\n    resolveNoneKeyframes() {\n        const { unresolvedKeyframes, name } = this;\n        const noneKeyframeIndexes = [];\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (isNone(unresolvedKeyframes[i])) {\n                noneKeyframeIndexes.push(i);\n            }\n        }\n        if (noneKeyframeIndexes.length) {\n            makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);\n        }\n    }\n    measureInitialState() {\n        const { element, unresolvedKeyframes, name } = this;\n        if (!element || !element.current)\n            return;\n        if (name === \"height\") {\n            this.suspendedScrollY = window.pageYOffset;\n        }\n        this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        unresolvedKeyframes[0] = this.measuredOrigin;\n        // Set final key frame to measure after next render\n        const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n        if (measureKeyframe !== undefined) {\n            element.getValue(name, measureKeyframe).jump(measureKeyframe, false);\n        }\n    }\n    measureEndState() {\n        var _a;\n        const { element, name, unresolvedKeyframes } = this;\n        if (!element || !element.current)\n            return;\n        const value = element.getValue(name);\n        value && value.jump(this.measuredOrigin, false);\n        const finalKeyframeIndex = unresolvedKeyframes.length - 1;\n        const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];\n        unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        if (finalKeyframe !== null && this.finalKeyframe === undefined) {\n            this.finalKeyframe = finalKeyframe;\n        }\n        // If we removed transform values, reapply them before the next render\n        if ((_a = this.removedTransforms) === null || _a === void 0 ? void 0 : _a.length) {\n            this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {\n                element\n                    .getValue(unsetTransformName)\n                    .set(unsetTransformValue);\n            });\n        }\n        this.resolveNoneKeyframes();\n    }\n}\n\nexport { DOMKeyframesResolver };\n","import { VisualElement } from '../VisualElement.mjs';\nimport { DOMKeyframesResolver } from './DOMKeyframesResolver.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    constructor() {\n        super(...arguments);\n        this.KeyframeResolver = DOMKeyframesResolver;\n    }\n    sortInstanceNodePosition(a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props.style\n            ? props.style[key]\n            : undefined;\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n    handleChildMotionValue() {\n        if (this.childSubscription) {\n            this.childSubscription();\n            delete this.childSubscription;\n        }\n        const { children } = this.props;\n        if (isMotionValue(children)) {\n            this.childSubscription = children.on(\"change\", (latest) => {\n                if (this.current) {\n                    this.current.textContent = `${latest}`;\n                }\n            });\n        }\n    }\n}\n\nexport { DOMVisualElement };\n","import { Fragment } from 'react';\nimport { 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)\n        : new HTMLVisualElement(options, {\n            allowProjection: Component !== Fragment,\n        });\n};\n\nexport { createDomVisualElement };\n","import { animations } from '../../motion/features/animations.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\n\n/**\n * @public\n */\nconst domAnimation = {\n    renderer: createDomVisualElement,\n    ...animations,\n    ...gestureAnimations,\n};\n\nexport { domAnimation };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px } from '../../../value/types/numbers/units.mjs';\nimport { transformPropOrder } from '../../html/utils/keys-transform.mjs';\n\nconst isNumOrPxType = (v) => v === number || v === px;\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/u);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/u);\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    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};\n// Alias translate longform names\npositionalValues.translateX = positionalValues.x;\npositionalValues.translateY = positionalValues.y;\n\nexport { isNumOrPxType, positionalValues, removeNonTranslationalTransform };\n","import { complex } from '../../../value/types/complex/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return defaultValueType.getAnimatableNone\n        ? defaultValueType.getAnimatableNone(value)\n        : undefined;\n}\n\nexport { getAnimatableNone };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n    ...numberValueTypes,\n    // Color props\n    color,\n    backgroundColor: color,\n    outlineColor: color,\n    fill: color,\n    stroke: color,\n    // Border props\n    borderColor: color,\n    borderTopColor: color,\n    borderRightColor: color,\n    borderBottomColor: color,\n    borderLeftColor: color,\n    filter,\n    WebkitFilter: filter,\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = (key) => defaultValueTypes[key];\n\nexport { defaultValueTypes, getDefaultValueType };\n","/**\n * ValueType for \"auto\"\n */\nconst auto = {\n    test: (v) => v === \"auto\",\n    parse: (v) => v,\n};\n\nexport { auto };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px, percent, degrees, vw, vh } from '../../../value/types/numbers/units.mjs';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\n","import { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { isCSSVariableName } from '../dom/utils/is-css-variable.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { transformProps } from './utils/keys-transform.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"html\";\n        this.renderInstance = renderHTML;\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariableName(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, props) {\n        buildHTMLStyles(renderState, latestValues, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","import { transformPropOrder } from './keys-transform.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    ...transformPropOrder,\n]);\n\nexport { positionalKeys };\n","const visualElementStore = new WeakMap();\n\nexport { visualElementStore };\n","import { frame } from '../../frameloop/frame.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { transformProps } from '../html/utils/keys-transform.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\nimport { updateSVGDimensions } from './utils/measure.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"svg\";\n        this.isSVGTag = false;\n        this.measureInstanceViewportBox = createBox;\n        this.updateDimensions = () => {\n            if (this.current && !this.renderState.dimensions) {\n                updateSVGDimensions(this.current, this.renderState);\n            }\n        };\n    }\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return instance.getAttribute(key);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n    onBindTransform() {\n        if (this.current && !this.renderState.dimensions) {\n            frame.postRender(this.updateDimensions);\n        }\n    }\n    build(renderState, latestValues, props) {\n        buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n    mount(instance) {\n        this.isSVGTag = isSVGTag(instance.tagName);\n        super.mount(instance);\n    }\n}\n\nexport { SVGVisualElement };\n","import { removeNonTranslationalTransform } from '../dom/utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    var _a;\n                    (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete());\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    readAllKeyframes();\n    measureAllKeyframes();\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        /**\n         * Track whether this resolver has completed. Once complete, it never\n         * needs to attempt keyframe resolution again.\n         */\n        this.isComplete = false;\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        /**\n         * Track whether this resolver is currently scheduled to resolve\n         * to allow it to be cancelled and resumed externally.\n         */\n        this.isScheduled = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.isScheduled = true;\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        /**\n         * If a keyframe is null, we hydrate it either by reading it from\n         * the instance, or propagating from previous keyframes.\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (unresolvedKeyframes[i] === null) {\n                /**\n                 * If the first keyframe is null, we need to find its value by sampling the element\n                 */\n                if (i === 0) {\n                    const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();\n                    const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n                    if (currentValue !== undefined) {\n                        unresolvedKeyframes[0] = currentValue;\n                    }\n                    else if (element && name) {\n                        const valueAsRead = element.readValue(name, finalKeyframe);\n                        if (valueAsRead !== undefined && valueAsRead !== null) {\n                            unresolvedKeyframes[0] = valueAsRead;\n                        }\n                    }\n                    if (unresolvedKeyframes[0] === undefined) {\n                        unresolvedKeyframes[0] = finalKeyframe;\n                    }\n                    if (motionValue && currentValue === undefined) {\n                        motionValue.set(unresolvedKeyframes[0]);\n                    }\n                }\n                else {\n                    unresolvedKeyframes[i] = unresolvedKeyframes[i - 1];\n                }\n            }\n        }\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete() {\n        this.isComplete = true;\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (!this.isComplete) {\n            this.isScheduled = false;\n            toResolve.delete(this);\n        }\n    }\n    resume() {\n        if (!this.isComplete)\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n","import { resolveVariantFromProps } from './resolve-variants.mjs';\n\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);\n}\n\nexport { resolveVariant };\n","import { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.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 || {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\n\nexport { setTarget };\n","const activeAnimations = {\n    layout: 0,\n    mainThread: 0,\n    waapi: 0,\n};\n\nexport { activeAnimations };\n","function addUniqueItem(arr, item) {\n    if (arr.indexOf(item) === -1)\n        arr.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    if (index > -1)\n        arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem([...arr], fromIndex, toIndex) {\n    const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        const [item] = arr.splice(fromIndex, 1);\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n","import { invariant, noop, progress } from 'motion-utils';\nimport { clamp } from './clamp.mjs';\nimport { mix } from './mix/index.mjs';\nimport { pipe } from './pipe.mjs';\n\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || mix;\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] || noop : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\n/**\n * Create a function that maps from a numerical input array to a generic output array.\n *\n * Accepts:\n *   - Numbers\n *   - Colors (hex, hsl, hsla, rgb, rgba)\n *   - Complex (combinations of one or more numbers or strings)\n *\n * ```jsx\n * const mixColor = interpolate([0, 1], ['#fff', '#000'])\n *\n * mixColor(0.5) // 'rgba(128, 128, 128, 1)'\n * ```\n *\n * TODO Revist this approach once we've moved to data models for values,\n * probably not needed to pregenerate mixer functions.\n *\n * @public\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    /**\n     * If we're only provided a single input, we can just make a function\n     * that returns the output.\n     */\n    if (inputLength === 1)\n        return () => output[0];\n    if (inputLength === 2 && output[0] === output[1])\n        return () => output[1];\n    const isZeroDeltaRange = input[0] === input[1];\n    // If input runs highest -> lowest, reverse both arrays\n    if (input[0] > input[inputLength - 1]) {\n        input = [...input].reverse();\n        output = [...output].reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const numMixers = mixers.length;\n    const interpolator = (v) => {\n        if (isZeroDeltaRange && v < input[0])\n            return output[0];\n        let i = 0;\n        if (numMixers > 1) {\n            for (; i < input.length - 2; i++) {\n                if (v < input[i + 1])\n                    break;\n            }\n        }\n        const progressInRange = progress(input[i], input[i + 1], v);\n        return mixers[i](progressInRange);\n    };\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\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+)?|\\.\\d+)$/u.test(v);\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nconst isZeroValueString = (v) => /^0[^.\\s]+$/u.test(v);\n\nexport { isZeroValueString };\n","// Adapted from https://gist.github.com/mjackson/5311256\nfunction 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","function mixImmediate(a, b) {\n    return (p) => (p > 0 ? b : a);\n}\n\nexport { mixImmediate };\n","import { mixNumber } from './number.mjs';\nimport { warning } from 'motion-utils';\nimport { hslaToRgba } from '../hsla-to-rgba.mjs';\nimport { hex } from '../../value/types/color/hex.mjs';\nimport { rgba } from '../../value/types/color/rgba.mjs';\nimport { hsla } from '../../value/types/color/hsla.mjs';\nimport { mixImmediate } from './immediate.mjs';\n\n// Linear color space blending\n// Explained https://www.youtube.com/watch?v=LKnqECcg6Gw\n// Demonstrated http://codepen.io/osublake/pen/xGVVaN\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const expo = v * (to * to - fromExpo) + fromExpo;\n    return expo < 0 ? 0 : Math.sqrt(expo);\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nfunction asRGBA(color) {\n    const type = getColorType(color);\n    warning(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`);\n    if (!Boolean(type))\n        return false;\n    let model = type.parse(color);\n    if (type === hsla) {\n        // TODO Remove this cast - needed since Motion's stricter typing\n        model = hslaToRgba(model);\n    }\n    return model;\n}\nconst mixColor = (from, to) => {\n    const fromRGBA = asRGBA(from);\n    const toRGBA = asRGBA(to);\n    if (!fromRGBA || !toRGBA) {\n        return mixImmediate(from, to);\n    }\n    const blended = { ...fromRGBA };\n    return (v) => {\n        blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);\n        blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);\n        blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);\n        blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v);\n        return rgba.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","const invisibleValues = new Set([\"none\", \"hidden\"]);\n/**\n * Returns a function that, when provided a progress value between 0 and 1,\n * will return the \"none\" or \"hidden\" string only when the progress is that of\n * the origin or target.\n */\nfunction mixVisibility(origin, target) {\n    if (invisibleValues.has(origin)) {\n        return (p) => (p <= 0 ? origin : target);\n    }\n    else {\n        return (p) => (p >= 1 ? target : origin);\n    }\n}\n\nexport { invisibleValues, mixVisibility };\n","import { mixNumber as mixNumber$1 } from './number.mjs';\nimport { mixColor } from './color.mjs';\nimport { pipe } from '../pipe.mjs';\nimport { warning } from 'motion-utils';\nimport { color } from '../../value/types/color/index.mjs';\nimport { complex, analyseComplexValue } from '../../value/types/complex/index.mjs';\nimport { isCSSVariableToken } from '../../render/dom/utils/is-css-variable.mjs';\nimport { invisibleValues, mixVisibility } from './visibility.mjs';\nimport { mixImmediate } from './immediate.mjs';\n\nfunction mixNumber(a, b) {\n    return (p) => mixNumber$1(a, b, p);\n}\nfunction getMixer(a) {\n    if (typeof a === \"number\") {\n        return mixNumber;\n    }\n    else if (typeof a === \"string\") {\n        return isCSSVariableToken(a)\n            ? mixImmediate\n            : color.test(a)\n                ? mixColor\n                : mixComplex;\n    }\n    else if (Array.isArray(a)) {\n        return mixArray;\n    }\n    else if (typeof a === \"object\") {\n        return color.test(a) ? mixColor : mixObject;\n    }\n    return mixImmediate;\n}\nfunction mixArray(a, b) {\n    const output = [...a];\n    const numValues = output.length;\n    const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));\n    return (p) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](p);\n        }\n        return output;\n    };\n}\nfunction mixObject(a, b) {\n    const output = { ...a, ...b };\n    const blendValue = {};\n    for (const key in output) {\n        if (a[key] !== undefined && b[key] !== undefined) {\n            blendValue[key] = getMixer(a[key])(a[key], b[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 matchOrder(origin, target) {\n    var _a;\n    const orderedOrigin = [];\n    const pointers = { color: 0, var: 0, number: 0 };\n    for (let i = 0; i < target.values.length; i++) {\n        const type = target.types[i];\n        const originIndex = origin.indexes[type][pointers[type]];\n        const originValue = (_a = origin.values[originIndex]) !== null && _a !== void 0 ? _a : 0;\n        orderedOrigin[i] = originValue;\n        pointers[type]++;\n    }\n    return orderedOrigin;\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyseComplexValue(origin);\n    const targetStats = analyseComplexValue(target);\n    const canInterpolate = originStats.indexes.var.length === targetStats.indexes.var.length &&\n        originStats.indexes.color.length === targetStats.indexes.color.length &&\n        originStats.indexes.number.length >= targetStats.indexes.number.length;\n    if (canInterpolate) {\n        if ((invisibleValues.has(origin) &&\n            !targetStats.values.length) ||\n            (invisibleValues.has(target) &&\n                !originStats.values.length)) {\n            return mixVisibility(origin, target);\n        }\n        return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), 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 mixImmediate(origin, target);\n    }\n};\n\nexport { getMixer, mixArray, mixComplex, mixObject };\n","import { getMixer } from './complex.mjs';\nimport { mixNumber } from './number.mjs';\n\nfunction mix(from, to, p) {\n    if (typeof from === \"number\" &&\n        typeof to === \"number\" &&\n        typeof p === \"number\") {\n        return mixNumber(from, to, p);\n    }\n    const mixer = getMixer(from);\n    return mixer(from, to);\n}\n\nexport { mix };\n","/*\n  Value in range from progress\n\n  Given a lower limit and an upper limit, we return the value within\n  that range as expressed by progress (usually a number from 0 to 1)\n\n  So progress = 0.5 would change\n\n  from -------- to\n\n  to\n\n  from ---- to\n\n  E.g. from = 10, to = 20, progress = 0.5 => 15\n\n  @param [number]: Lower limit of range\n  @param [number]: Upper limit of range\n  @param [number]: The progress between lower and upper limits expressed 0-1\n  @return [number]: Value as calculated from progress within range (not limited within range)\n*/\nconst mixNumber = (from, to, progress) => {\n    return from + (to - from) * progress;\n};\n\nexport { mixNumber };\n","import { fillOffset } from './fill.mjs';\n\nfunction defaultOffset(arr) {\n    const offset = [0];\n    fillOffset(offset, arr.length - 1);\n    return offset;\n}\n\nexport { defaultOffset };\n","import { progress } from 'motion-utils';\nimport { mixNumber } from '../mix/number.mjs';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mixNumber(min, 1, offsetProgress));\n    }\n}\n\nexport { fillOffset };\n","/**\n * Pipe\n * Compose other transformers to run linearily\n * pipe(min(20), max(40))\n * @param  {...functions} transformers\n * @return {function}\n */\nconst combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\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","// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nclass SubscriptionManager {\n    constructor() {\n        this.subscriptions = [];\n    }\n    add(handler) {\n        addUniqueItem(this.subscriptions, handler);\n        return () => removeItem(this.subscriptions, handler);\n    }\n    notify(a, b, c) {\n        const numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (let i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                const handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    }\n    getSize() {\n        return this.subscriptions.length;\n    }\n    clear() {\n        this.subscriptions.length = 0;\n    }\n}\n\nexport { SubscriptionManager };\n","const instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","/*\n  Convert velocity into velocity per second\n\n  @param [number]: Unit per frame\n  @param [number]: Frame duration in ms\n*/\nfunction velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","import { time } from '../frameloop/sync-time.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    constructor(init, options = {}) {\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"12.4.10\";\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = null;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v, render = true) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev && this.events.change) {\n                this.events.change.notify(this.current);\n            }\n            // Update render subscribers\n            if (render && this.events.renderRequest) {\n                this.events.renderRequest.notify(this.current);\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n        if (this.canTrackVelocity === null && current !== undefined) {\n            this.canTrackVelocity = isFloat(this.current);\n        }\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v, render = true) {\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v, endAnimation = true) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        endAnimation && this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nfunction motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n\nexport { MotionValue, collectMotionValues, motionValue };\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 we have 6 characters, ie #FF0000\n    if (v.length > 5) {\n        r = v.substring(1, 3);\n        g = v.substring(3, 5);\n        b = v.substring(5, 7);\n        a = v.substring(7, 9);\n        // Or we have 3 characters, ie #F00\n    }\n    else {\n        r = v.substring(1, 2);\n        g = v.substring(2, 3);\n        b = v.substring(3, 4);\n        a = v.substring(4, 5);\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: /*@__PURE__*/ 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/sanitize.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: /*@__PURE__*/ isColorString(\"hsl\", \"hue\"),\n    parse: /*@__PURE__*/ 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 { 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 typeof v === \"string\"\n            ? v\n            : v.hasOwnProperty(\"red\")\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { clamp } from '../../../utils/clamp.mjs';\nimport { alpha, number } from '../numbers/index.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = (v) => clamp(0, 255, v);\nconst rgbUnit = {\n    ...number,\n    transform: (v) => Math.round(clampRgbUnit(v)),\n};\nconst rgba = {\n    test: /*@__PURE__*/ isColorString(\"rgb\", \"red\"),\n    parse: /*@__PURE__*/ 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","function isNullish(v) {\n    return v == null;\n}\n\nexport { isNullish };\n","const singleColorRegex = /^(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))$/iu;\n\nexport { singleColorRegex };\n","import { floatRegex } from '../utils/float-regex.mjs';\nimport { isNullish } from '../utils/is-nullish.mjs';\nimport { singleColorRegex } from '../utils/single-color-regex.mjs';\n\n/**\n * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,\n * but false if a number or multiple colors\n */\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((typeof v === \"string\" &&\n        singleColorRegex.test(v) &&\n        v.startsWith(type)) ||\n        (testProp &&\n            !isNullish(v) &&\n            Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (typeof v !== \"string\")\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/float-regex.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /\\b([a-z-]*)\\(.*?\\)/gu;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n","const colorRegex = /(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))/giu;\n\nexport { colorRegex };\n","import { color } from '../color/index.mjs';\nimport { colorRegex } from '../utils/color-regex.mjs';\nimport { floatRegex } from '../utils/float-regex.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\n\nfunction test(v) {\n    var _a, _b;\n    return (isNaN(v) &&\n        typeof v === \"string\" &&\n        (((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) +\n            (((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) >\n            0);\n}\nconst NUMBER_TOKEN = \"number\";\nconst COLOR_TOKEN = \"color\";\nconst VAR_TOKEN = \"var\";\nconst VAR_FUNCTION_TOKEN = \"var(\";\nconst SPLIT_TOKEN = \"${}\";\n// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`\nconst complexRegex = /var\\s*\\(\\s*--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)|#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\)|-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/giu;\nfunction analyseComplexValue(value) {\n    const originalValue = value.toString();\n    const values = [];\n    const indexes = {\n        color: [],\n        number: [],\n        var: [],\n    };\n    const types = [];\n    let i = 0;\n    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {\n        if (color.test(parsedValue)) {\n            indexes.color.push(i);\n            types.push(COLOR_TOKEN);\n            values.push(color.parse(parsedValue));\n        }\n        else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {\n            indexes.var.push(i);\n            types.push(VAR_TOKEN);\n            values.push(parsedValue);\n        }\n        else {\n            indexes.number.push(i);\n            types.push(NUMBER_TOKEN);\n            values.push(parseFloat(parsedValue));\n        }\n        ++i;\n        return SPLIT_TOKEN;\n    });\n    const split = tokenised.split(SPLIT_TOKEN);\n    return { values, split, indexes, types };\n}\nfunction parseComplexValue(v) {\n    return analyseComplexValue(v).values;\n}\nfunction createTransformer(source) {\n    const { split, types } = analyseComplexValue(source);\n    const numSections = split.length;\n    return (v) => {\n        let output = \"\";\n        for (let i = 0; i < numSections; i++) {\n            output += split[i];\n            if (v[i] !== undefined) {\n                const type = types[i];\n                if (type === NUMBER_TOKEN) {\n                    output += sanitize(v[i]);\n                }\n                else if (type === COLOR_TOKEN) {\n                    output += color.transform(v[i]);\n                }\n                else {\n                    output += v[i];\n                }\n            }\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === \"number\" ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parseComplexValue(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = {\n    test,\n    parse: parseComplexValue,\n    createTransformer,\n    getAnimatableNone,\n};\n\nexport { analyseComplexValue, complex };\n","const floatRegex = /-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/gu;\n\nexport { floatRegex };\n","// If this number is a decimal, make it just five decimal places\n// to avoid exponents\nconst sanitize = (v) => Math.round(v * 100000) / 100000;\n\nexport { sanitize };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n","import { isWillChangeMotionValue } from './is.mjs';\n\nfunction addValueToWillChange(visualElement, key) {\n    const willChange = visualElement.getValue(\"willChange\");\n    /**\n     * It could be that a user has set willChange to a regular MotionValue,\n     * in which case we can't add the value to it.\n     */\n    if (isWillChangeMotionValue(willChange)) {\n        return willChange.add(key);\n    }\n}\n\nexport { addValueToWillChange };\n","import { memo } from 'motion-utils';\n\nconst supportsScrollTimeline = memo(() => window.ScrollTimeline !== undefined);\n\nexport { supportsScrollTimeline };\n","import { supportsScrollTimeline } from '../../utils/supports/scroll-timeline.mjs';\n\nclass BaseGroupPlaybackControls {\n    constructor(animations) {\n        // Bound to accomodate common `return animation.stop` pattern\n        this.stop = () => this.runAll(\"stop\");\n        this.animations = animations.filter(Boolean);\n    }\n    get finished() {\n        // Support for new finished Promise and legacy thennable API\n        return Promise.all(this.animations.map((animation) => \"finished\" in animation ? animation.finished : animation));\n    }\n    /**\n     * TODO: Filter out cancelled or stopped animations before returning\n     */\n    getAll(propName) {\n        return this.animations[0][propName];\n    }\n    setAll(propName, newValue) {\n        for (let i = 0; i < this.animations.length; i++) {\n            this.animations[i][propName] = newValue;\n        }\n    }\n    attachTimeline(timeline, fallback) {\n        const subscriptions = this.animations.map((animation) => {\n            if (supportsScrollTimeline() && animation.attachTimeline) {\n                return animation.attachTimeline(timeline);\n            }\n            else if (typeof fallback === \"function\") {\n                return fallback(animation);\n            }\n        });\n        return () => {\n            subscriptions.forEach((cancel, i) => {\n                cancel && cancel();\n                this.animations[i].stop();\n            });\n        };\n    }\n    get time() {\n        return this.getAll(\"time\");\n    }\n    set time(time) {\n        this.setAll(\"time\", time);\n    }\n    get speed() {\n        return this.getAll(\"speed\");\n    }\n    set speed(speed) {\n        this.setAll(\"speed\", speed);\n    }\n    get startTime() {\n        return this.getAll(\"startTime\");\n    }\n    get duration() {\n        let max = 0;\n        for (let i = 0; i < this.animations.length; i++) {\n            max = Math.max(max, this.animations[i].duration);\n        }\n        return max;\n    }\n    runAll(methodName) {\n        this.animations.forEach((controls) => controls[methodName]());\n    }\n    flatten() {\n        this.runAll(\"flatten\");\n    }\n    play() {\n        this.runAll(\"play\");\n    }\n    pause() {\n        this.runAll(\"pause\");\n    }\n    cancel() {\n        this.runAll(\"cancel\");\n    }\n    complete() {\n        this.runAll(\"complete\");\n    }\n}\n\nexport { BaseGroupPlaybackControls };\n","import { BaseGroupPlaybackControls } from './BaseGroup.mjs';\n\n/**\n * TODO: This is a temporary class to support the legacy\n * thennable API\n */\nclass GroupPlaybackControls extends BaseGroupPlaybackControls {\n    then(onResolve, onReject) {\n        return Promise.all(this.animations).then(onResolve).catch(onReject);\n    }\n}\n\nexport { GroupPlaybackControls };\n","function getValueTransition(transition, key) {\n    return transition\n        ? transition[key] ||\n            transition[\"default\"] ||\n            transition\n        : undefined;\n}\n\nexport { getValueTransition };\n","/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n","import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n","function isGenerator(type) {\n    return typeof type === \"function\";\n}\n\nexport { isGenerator };\n","function attachTimeline(animation, timeline) {\n    animation.timeline = timeline;\n    animation.onfinish = null;\n}\n\nexport { attachTimeline };\n","import { millisecondsToSeconds, secondsToMilliseconds, noop } from 'motion-utils';\nimport { attachTimeline } from './utils/attach-timeline.mjs';\n\nclass NativeAnimationControls {\n    constructor(animation) {\n        this.animation = animation;\n    }\n    get duration() {\n        var _a, _b, _c;\n        const durationInMs = ((_b = (_a = this.animation) === null || _a === void 0 ? void 0 : _a.effect) === null || _b === void 0 ? void 0 : _b.getComputedTiming().duration) ||\n            ((_c = this.options) === null || _c === void 0 ? void 0 : _c.duration) ||\n            300;\n        return millisecondsToSeconds(Number(durationInMs));\n    }\n    get time() {\n        var _a;\n        if (this.animation) {\n            return millisecondsToSeconds(((_a = this.animation) === null || _a === void 0 ? void 0 : _a.currentTime) || 0);\n        }\n        return 0;\n    }\n    set time(newTime) {\n        if (this.animation) {\n            this.animation.currentTime = secondsToMilliseconds(newTime);\n        }\n    }\n    get speed() {\n        return this.animation ? this.animation.playbackRate : 1;\n    }\n    set speed(newSpeed) {\n        if (this.animation) {\n            this.animation.playbackRate = newSpeed;\n        }\n    }\n    get state() {\n        return this.animation ? this.animation.playState : \"finished\";\n    }\n    get startTime() {\n        return this.animation ? this.animation.startTime : null;\n    }\n    get finished() {\n        return this.animation ? this.animation.finished : Promise.resolve();\n    }\n    play() {\n        this.animation && this.animation.play();\n    }\n    pause() {\n        this.animation && this.animation.pause();\n    }\n    stop() {\n        if (!this.animation ||\n            this.state === \"idle\" ||\n            this.state === \"finished\") {\n            return;\n        }\n        if (this.animation.commitStyles) {\n            this.animation.commitStyles();\n        }\n        this.cancel();\n    }\n    flatten() {\n        var _a;\n        if (!this.animation)\n            return;\n        (_a = this.animation.effect) === null || _a === void 0 ? void 0 : _a.updateTiming({ easing: \"linear\" });\n    }\n    attachTimeline(timeline) {\n        if (this.animation)\n            attachTimeline(this.animation, timeline);\n        return noop;\n    }\n    complete() {\n        this.animation && this.animation.finish();\n    }\n    cancel() {\n        try {\n            this.animation && this.animation.cancel();\n        }\n        catch (e) { }\n    }\n}\n\nexport { NativeAnimationControls };\n","const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === \"number\";\n\nexport { isBezierDefinition };\n","/**\n * Add the ability for test suites to manually set support flags\n * to better test more environments.\n */\nconst supportsFlags = {\n    linearEasing: undefined,\n};\n\nexport { supportsFlags };\n","import { memo } from 'motion-utils';\nimport { supportsFlags } from './flags.mjs';\n\nfunction memoSupports(callback, supportsFlag) {\n    const memoized = memo(callback);\n    return () => { var _a; return (_a = supportsFlags[supportsFlag]) !== null && _a !== void 0 ? _a : memoized(); };\n}\n\nexport { memoSupports };\n","import { memoSupports } from './memo.mjs';\n\nconst supportsLinearEasing = /*@__PURE__*/ memoSupports(() => {\n    try {\n        document\n            .createElement(\"div\")\n            .animate({ opacity: 0 }, { easing: \"linear(0, 1)\" });\n    }\n    catch (e) {\n        return false;\n    }\n    return true;\n}, \"linearEasing\");\n\nexport { supportsLinearEasing };\n","import { progress } from 'motion-utils';\n\nconst generateLinearEasing = (easing, duration, // as milliseconds\nresolution = 10 // as milliseconds\n) => {\n    let points = \"\";\n    const numPoints = Math.max(Math.round(duration / resolution), 2);\n    for (let i = 0; i < numPoints; i++) {\n        points += easing(progress(0, numPoints - 1, i)) + \", \";\n    }\n    return `linear(${points.substring(0, points.length - 2)})`;\n};\n\nexport { generateLinearEasing };\n","import { isBezierDefinition } from '../../../utils/is-bezier-definition.mjs';\nimport { supportsLinearEasing } from '../../../utils/supports/linear-easing.mjs';\nimport { generateLinearEasing } from './linear.mjs';\n\nfunction isWaapiSupportedEasing(easing) {\n    return Boolean((typeof easing === \"function\" && supportsLinearEasing()) ||\n        !easing ||\n        (typeof easing === \"string\" &&\n            (easing in supportedWaapiEasing || supportsLinearEasing())) ||\n        isBezierDefinition(easing) ||\n        (Array.isArray(easing) && easing.every(isWaapiSupportedEasing)));\n}\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\nconst supportedWaapiEasing = {\n    linear: \"linear\",\n    ease: \"ease\",\n    easeIn: \"ease-in\",\n    easeOut: \"ease-out\",\n    easeInOut: \"ease-in-out\",\n    circIn: /*@__PURE__*/ cubicBezierAsString([0, 0.65, 0.55, 1]),\n    circOut: /*@__PURE__*/ cubicBezierAsString([0.55, 0, 1, 0.45]),\n    backIn: /*@__PURE__*/ cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),\n    backOut: /*@__PURE__*/ cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),\n};\nfunction mapEasingToNativeEasing(easing, duration) {\n    if (!easing) {\n        return undefined;\n    }\n    else if (typeof easing === \"function\" && supportsLinearEasing()) {\n        return generateLinearEasing(easing, duration);\n    }\n    else if (isBezierDefinition(easing)) {\n        return cubicBezierAsString(easing);\n    }\n    else if (Array.isArray(easing)) {\n        return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) ||\n            supportedWaapiEasing.easeOut);\n    }\n    else {\n        return supportedWaapiEasing[easing];\n    }\n}\n\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing };\n","const isDragging = {\n    x: false,\n    y: false,\n};\nfunction isDragActive() {\n    return isDragging.x || isDragging.y;\n}\n\nexport { isDragActive, isDragging };\n","function resolveElements(elementOrSelector, scope, selectorCache) {\n    var _a;\n    if (elementOrSelector instanceof EventTarget) {\n        return [elementOrSelector];\n    }\n    else if (typeof elementOrSelector === \"string\") {\n        let root = document;\n        if (scope) {\n            // TODO: Refactor to utils package\n            // invariant(\n            //     Boolean(scope.current),\n            //     \"Scope provided, but no element detected.\"\n            // )\n            root = scope.current;\n        }\n        const elements = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);\n        return elements ? Array.from(elements) : [];\n    }\n    return Array.from(elementOrSelector);\n}\n\nexport { resolveElements };\n","import { resolveElements } from '../../utils/resolve-elements.mjs';\n\nfunction setupGesture(elementOrSelector, options) {\n    const elements = resolveElements(elementOrSelector);\n    const gestureAbortController = new AbortController();\n    const eventOptions = {\n        passive: true,\n        ...options,\n        signal: gestureAbortController.signal,\n    };\n    const cancel = () => gestureAbortController.abort();\n    return [elements, eventOptions, cancel];\n}\n\nexport { setupGesture };\n","import { isDragActive } from './drag/state/is-active.mjs';\nimport { setupGesture } from './utils/setup.mjs';\n\nfunction isValidHover(event) {\n    return !(event.pointerType === \"touch\" || isDragActive());\n}\n/**\n * Create a hover gesture. hover() is different to .addEventListener(\"pointerenter\")\n * in that it has an easier syntax, filters out polyfilled touch events, interoperates\n * with drag gestures, and automatically removes the \"pointerennd\" event listener when the hover ends.\n *\n * @public\n */\nfunction hover(elementOrSelector, onHoverStart, options = {}) {\n    const [elements, eventOptions, cancel] = setupGesture(elementOrSelector, options);\n    const onPointerEnter = (enterEvent) => {\n        if (!isValidHover(enterEvent))\n            return;\n        const { target } = enterEvent;\n        const onHoverEnd = onHoverStart(target, enterEvent);\n        if (typeof onHoverEnd !== \"function\" || !target)\n            return;\n        const onPointerLeave = (leaveEvent) => {\n            if (!isValidHover(leaveEvent))\n                return;\n            onHoverEnd(leaveEvent);\n            target.removeEventListener(\"pointerleave\", onPointerLeave);\n        };\n        target.addEventListener(\"pointerleave\", onPointerLeave, eventOptions);\n    };\n    elements.forEach((element) => {\n        element.addEventListener(\"pointerenter\", onPointerEnter, eventOptions);\n    });\n    return cancel;\n}\n\nexport { hover };\n","function capturePointer(event, action) {\n    const actionName = `${action}PointerCapture`;\n    if (event.target instanceof Element &&\n        actionName in event.target &&\n        event.pointerId !== undefined) {\n        try {\n            event.target[actionName](event.pointerId);\n        }\n        catch (e) { }\n    }\n}\n\nexport { capturePointer };\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","const isPrimaryPointer = (event) => {\n    if (event.pointerType === \"mouse\") {\n        return typeof event.button !== \"number\" || event.button <= 0;\n    }\n    else {\n        /**\n         * isPrimary is true for all mice buttons, whereas every touch point\n         * is regarded as its own input. So subsequent concurrent touch points\n         * will be false.\n         *\n         * Specifically match against false here as incomplete versions of\n         * PointerEvents in very old browser might have it set as undefined.\n         */\n        return event.isPrimary !== false;\n    }\n};\n\nexport { isPrimaryPointer };\n","const focusableElements = new Set([\n    \"BUTTON\",\n    \"INPUT\",\n    \"SELECT\",\n    \"TEXTAREA\",\n    \"A\",\n]);\nfunction isElementKeyboardAccessible(element) {\n    return (focusableElements.has(element.tagName) ||\n        element.tabIndex !== -1);\n}\n\nexport { isElementKeyboardAccessible };\n","const isPressing = new WeakSet();\n\nexport { isPressing };\n","import { isPressing } from './state.mjs';\n\n/**\n * Filter out events that are not \"Enter\" keys.\n */\nfunction filterEvents(callback) {\n    return (event) => {\n        if (event.key !== \"Enter\")\n            return;\n        callback(event);\n    };\n}\nfunction firePointerEvent(target, type) {\n    target.dispatchEvent(new PointerEvent(\"pointer\" + type, { isPrimary: true, bubbles: true }));\n}\nconst enableKeyboardPress = (focusEvent, eventOptions) => {\n    const element = focusEvent.currentTarget;\n    if (!element)\n        return;\n    const handleKeydown = filterEvents(() => {\n        if (isPressing.has(element))\n            return;\n        firePointerEvent(element, \"down\");\n        const handleKeyup = filterEvents(() => {\n            firePointerEvent(element, \"up\");\n        });\n        const handleBlur = () => firePointerEvent(element, \"cancel\");\n        element.addEventListener(\"keyup\", handleKeyup, eventOptions);\n        element.addEventListener(\"blur\", handleBlur, eventOptions);\n    });\n    element.addEventListener(\"keydown\", handleKeydown, eventOptions);\n    /**\n     * Add an event listener that fires on blur to remove the keydown events.\n     */\n    element.addEventListener(\"blur\", () => element.removeEventListener(\"keydown\", handleKeydown), eventOptions);\n};\n\nexport { enableKeyboardPress };\n","import { isDragActive } from '../drag/state/is-active.mjs';\nimport { capturePointer } from '../utils/capture-pointer.mjs';\nimport { isNodeOrChild } from '../utils/is-node-or-child.mjs';\nimport { isPrimaryPointer } from '../utils/is-primary-pointer.mjs';\nimport { setupGesture } from '../utils/setup.mjs';\nimport { isElementKeyboardAccessible } from './utils/is-keyboard-accessible.mjs';\nimport { enableKeyboardPress } from './utils/keyboard.mjs';\nimport { isPressing } from './utils/state.mjs';\n\n/**\n * Filter out events that are not primary pointer events, or are triggering\n * while a Motion gesture is active.\n */\nfunction isValidPressEvent(event) {\n    return isPrimaryPointer(event) && !isDragActive();\n}\n/**\n * Create a press gesture.\n *\n * Press is different to `\"pointerdown\"`, `\"pointerup\"` in that it\n * automatically filters out secondary pointer events like right\n * click and multitouch.\n *\n * It also adds accessibility support for keyboards, where\n * an element with a press gesture will receive focus and\n *  trigger on Enter `\"keydown\"` and `\"keyup\"` events.\n *\n * This is different to a browser's `\"click\"` event, which does\n * respond to keyboards but only for the `\"click\"` itself, rather\n * than the press start and end/cancel. The element also needs\n * to be focusable for this to work, whereas a press gesture will\n * make an element focusable by default.\n *\n * @public\n */\nfunction press(targetOrSelector, onPressStart, options = {}) {\n    const [targets, eventOptions, cancelEvents] = setupGesture(targetOrSelector, options);\n    const startPress = (startEvent) => {\n        const target = startEvent.currentTarget;\n        if (!target || !isValidPressEvent(startEvent) || isPressing.has(target))\n            return;\n        isPressing.add(target);\n        capturePointer(startEvent, \"set\");\n        const onPressEnd = onPressStart(target, startEvent);\n        const onPointerEnd = (endEvent, success) => {\n            target.removeEventListener(\"pointerup\", onPointerUp);\n            target.removeEventListener(\"pointercancel\", onPointerCancel);\n            capturePointer(endEvent, \"release\");\n            if (!isValidPressEvent(endEvent) || !isPressing.has(target)) {\n                return;\n            }\n            isPressing.delete(target);\n            if (typeof onPressEnd === \"function\") {\n                onPressEnd(endEvent, { success });\n            }\n        };\n        const onPointerUp = (upEvent) => {\n            const isOutside = !upEvent.isTrusted\n                ? false\n                : checkOutside(upEvent, target instanceof Element\n                    ? target.getBoundingClientRect()\n                    : {\n                        left: 0,\n                        top: 0,\n                        right: window.innerWidth,\n                        bottom: window.innerHeight,\n                    });\n            if (isOutside) {\n                onPointerEnd(upEvent, false);\n            }\n            else {\n                onPointerEnd(upEvent, !(target instanceof Element) ||\n                    isNodeOrChild(target, upEvent.target));\n            }\n        };\n        const onPointerCancel = (cancelEvent) => {\n            onPointerEnd(cancelEvent, false);\n        };\n        target.addEventListener(\"pointerup\", onPointerUp, eventOptions);\n        target.addEventListener(\"pointercancel\", onPointerCancel, eventOptions);\n        target.addEventListener(\"lostpointercapture\", onPointerCancel, eventOptions);\n    };\n    targets.forEach((target) => {\n        target = options.useGlobalTarget ? window : target;\n        let canAddKeyboardAccessibility = false;\n        if (target instanceof HTMLElement) {\n            canAddKeyboardAccessibility = true;\n            if (!isElementKeyboardAccessible(target) &&\n                target.getAttribute(\"tabindex\") === null) {\n                target.tabIndex = 0;\n            }\n        }\n        target.addEventListener(\"pointerdown\", startPress, eventOptions);\n        if (canAddKeyboardAccessibility) {\n            target.addEventListener(\"focus\", (event) => enableKeyboardPress(event, eventOptions), eventOptions);\n        }\n    });\n    return cancelEvents;\n}\nfunction checkOutside(event, rect) {\n    return (event.clientX < rect.left ||\n        event.clientX > rect.right ||\n        event.clientY < rect.top ||\n        event.clientY > rect.bottom);\n}\n\nexport { press };\n","import { secondsToMilliseconds } from 'motion-utils';\nimport { supportsLinearEasing } from '../../../utils/supports/linear-easing.mjs';\nimport { createGeneratorEasing } from '../../generators/utils/create-generator-easing.mjs';\nimport { isGenerator } from '../../generators/utils/is-generator.mjs';\nimport { mapEasingToNativeEasing } from './easing.mjs';\n\nconst defaultEasing = \"easeOut\";\nfunction applyGeneratorOptions(options) {\n    var _a;\n    if (isGenerator(options.type)) {\n        const generatorOptions = createGeneratorEasing(options, 100, options.type);\n        options.ease = supportsLinearEasing()\n            ? generatorOptions.ease\n            : defaultEasing;\n        options.duration = secondsToMilliseconds(generatorOptions.duration);\n        options.type = \"keyframes\";\n    }\n    else {\n        options.duration = secondsToMilliseconds((_a = options.duration) !== null && _a !== void 0 ? _a : 0.3);\n        options.ease = options.ease || defaultEasing;\n    }\n}\n// TODO: Reuse for NativeAnimation\nfunction convertMotionOptionsToNative(valueName, keyframes, options) {\n    var _a;\n    const nativeKeyframes = {};\n    const nativeOptions = {\n        fill: \"both\",\n        easing: \"linear\",\n        composite: \"replace\",\n    };\n    nativeOptions.delay = secondsToMilliseconds((_a = options.delay) !== null && _a !== void 0 ? _a : 0);\n    applyGeneratorOptions(options);\n    nativeOptions.duration = options.duration;\n    const { ease, times } = options;\n    if (times)\n        nativeKeyframes.offset = times;\n    nativeKeyframes[valueName] = keyframes;\n    const easing = mapEasingToNativeEasing(ease, options.duration);\n    /**\n     * If this is an easing array, apply to keyframes, not animation as a whole\n     */\n    if (Array.isArray(easing)) {\n        nativeKeyframes.easing = easing;\n    }\n    else {\n        nativeOptions.easing = easing;\n    }\n    return {\n        keyframes: nativeKeyframes,\n        options: nativeOptions,\n    };\n}\n\nexport { applyGeneratorOptions, convertMotionOptionsToNative };\n","import { NativeAnimationControls } from './NativeAnimationControls.mjs';\nimport { convertMotionOptionsToNative } from './utils/convert-options.mjs';\n\nclass PseudoAnimation extends NativeAnimationControls {\n    constructor(target, pseudoElement, valueName, keyframes, options) {\n        const animationOptions = convertMotionOptionsToNative(valueName, keyframes, options);\n        const animation = target.animate(animationOptions.keyframes, {\n            pseudoElement,\n            ...animationOptions.options,\n        });\n        super(animation);\n    }\n}\n\nexport { PseudoAnimation };\n","let pendingRules = {};\nlet style = null;\nconst css = {\n    set: (selector, values) => {\n        pendingRules[selector] = values;\n    },\n    commit: () => {\n        if (!style) {\n            style = document.createElement(\"style\");\n            style.id = \"motion-view\";\n        }\n        let cssText = \"\";\n        for (const selector in pendingRules) {\n            const rule = pendingRules[selector];\n            cssText += `${selector} {\\n`;\n            for (const [property, value] of Object.entries(rule)) {\n                cssText += `  ${property}: ${value};\\n`;\n            }\n            cssText += \"}\\n\";\n        }\n        style.textContent = cssText;\n        document.head.appendChild(style);\n        pendingRules = {};\n    },\n    remove: () => {\n        if (style && style.parentElement) {\n            style.parentElement.removeChild(style);\n        }\n    },\n};\n\nexport { css };\n","import { secondsToMilliseconds } from 'motion-utils';\nimport { BaseGroupPlaybackControls } from '../animation/controls/BaseGroup.mjs';\nimport { getValueTransition } from '../animation/utils/get-value-transition.mjs';\nimport { NativeAnimationControls } from '../animation/waapi/NativeAnimationControls.mjs';\nimport { PseudoAnimation } from '../animation/waapi/PseudoAnimation.mjs';\nimport { applyGeneratorOptions } from '../animation/waapi/utils/convert-options.mjs';\nimport { mapEasingToNativeEasing } from '../animation/waapi/utils/easing.mjs';\nimport { chooseLayerType } from './utils/choose-layer-type.mjs';\nimport { css } from './utils/css.mjs';\nimport { getLayerName } from './utils/get-layer-name.mjs';\nimport { getViewAnimations } from './utils/get-view-animations.mjs';\nimport { hasTarget } from './utils/has-target.mjs';\n\nconst definitionNames = [\"layout\", \"enter\", \"exit\", \"new\", \"old\"];\nfunction startViewAnimation(update, defaultOptions, targets) {\n    if (!document.startViewTransition) {\n        return new Promise(async (resolve) => {\n            await update();\n            resolve(new BaseGroupPlaybackControls([]));\n        });\n    }\n    // TODO: Go over existing targets and ensure they all have ids\n    /**\n     * If we don't have any animations defined for the root target,\n     * remove it from being captured.\n     */\n    if (!hasTarget(\"root\", targets)) {\n        css.set(\":root\", {\n            \"view-transition-name\": \"none\",\n        });\n    }\n    /**\n     * Set the timing curve to linear for all view transition layers.\n     * This gets baked into the keyframes, which can't be changed\n     * without breaking the generated animation.\n     *\n     * This allows us to set easing via updateTiming - which can be changed.\n     */\n    css.set(\"::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*)\", { \"animation-timing-function\": \"linear !important\" });\n    css.commit(); // Write\n    const transition = document.startViewTransition(async () => {\n        await update();\n        // TODO: Go over new targets and ensure they all have ids\n    });\n    transition.finished.finally(() => {\n        css.remove(); // Write\n    });\n    return new Promise((resolve) => {\n        transition.ready.then(() => {\n            var _a;\n            const generatedViewAnimations = getViewAnimations();\n            const animations = [];\n            /**\n             * Create animations for our definitions\n             */\n            targets.forEach((definition, target) => {\n                // TODO: If target is not \"root\", resolve elements\n                // and iterate over each\n                for (const key of definitionNames) {\n                    if (!definition[key])\n                        continue;\n                    const { keyframes, options } = definition[key];\n                    for (let [valueName, valueKeyframes] of Object.entries(keyframes)) {\n                        if (!valueKeyframes)\n                            continue;\n                        const valueOptions = {\n                            ...getValueTransition(defaultOptions, valueName),\n                            ...getValueTransition(options, valueName),\n                        };\n                        const type = chooseLayerType(key);\n                        /**\n                         * If this is an opacity animation, and keyframes are not an array,\n                         * we need to convert them into an array and set an initial value.\n                         */\n                        if (valueName === \"opacity\" &&\n                            !Array.isArray(valueKeyframes)) {\n                            const initialValue = type === \"new\" ? 0 : 1;\n                            valueKeyframes = [initialValue, valueKeyframes];\n                        }\n                        /**\n                         * Resolve stagger function if provided.\n                         */\n                        if (typeof valueOptions.delay === \"function\") {\n                            valueOptions.delay = valueOptions.delay(0, 1);\n                        }\n                        const animation = new PseudoAnimation(document.documentElement, `::view-transition-${type}(${target})`, valueName, valueKeyframes, valueOptions);\n                        animations.push(animation);\n                    }\n                }\n            });\n            /**\n             * Handle browser generated animations\n             */\n            for (const animation of generatedViewAnimations) {\n                if (animation.playState === \"finished\")\n                    continue;\n                const { effect } = animation;\n                if (!effect || !(effect instanceof KeyframeEffect))\n                    continue;\n                const { pseudoElement } = effect;\n                if (!pseudoElement)\n                    continue;\n                const name = getLayerName(pseudoElement);\n                if (!name)\n                    continue;\n                const targetDefinition = targets.get(name.layer);\n                if (!targetDefinition) {\n                    /**\n                     * If transition name is group then update the timing of the animation\n                     * whereas if it's old or new then we could possibly replace it using\n                     * the above method.\n                     */\n                    const transitionName = name.type === \"group\" ? \"layout\" : \"\";\n                    const animationTransition = {\n                        ...getValueTransition(defaultOptions, transitionName),\n                    };\n                    applyGeneratorOptions(animationTransition);\n                    const easing = mapEasingToNativeEasing(animationTransition.ease, animationTransition.duration);\n                    effect.updateTiming({\n                        delay: secondsToMilliseconds((_a = animationTransition.delay) !== null && _a !== void 0 ? _a : 0),\n                        duration: animationTransition.duration,\n                        easing,\n                    });\n                    animations.push(new NativeAnimationControls(animation));\n                }\n                else if (hasOpacity(targetDefinition, \"enter\") &&\n                    hasOpacity(targetDefinition, \"exit\") &&\n                    effect\n                        .getKeyframes()\n                        .some((keyframe) => keyframe.mixBlendMode)) {\n                    animations.push(new NativeAnimationControls(animation));\n                }\n                else {\n                    animation.cancel();\n                }\n            }\n            resolve(new BaseGroupPlaybackControls(animations));\n        });\n    });\n}\nfunction hasOpacity(target, key) {\n    var _a;\n    return (_a = target === null || target === void 0 ? void 0 : target[key]) === null || _a === void 0 ? void 0 : _a.keyframes.opacity;\n}\n\nexport { startViewAnimation };\n","import { noop } from 'motion-utils';\nimport { startViewAnimation } from './start.mjs';\n\n/**\n * TODO:\n * - Create view transition on next tick\n * - Replace animations with Motion animations\n * - Return GroupAnimation on next tick\n */\nclass ViewTransitionBuilder {\n    constructor(update, options = {}) {\n        this.currentTarget = \"root\";\n        this.targets = new Map();\n        this.notifyReady = noop;\n        this.readyPromise = new Promise((resolve) => {\n            this.notifyReady = resolve;\n        });\n        queueMicrotask(() => {\n            startViewAnimation(update, options, this.targets).then((animation) => this.notifyReady(animation));\n        });\n    }\n    get(selector) {\n        this.currentTarget = selector;\n        return this;\n    }\n    layout(keyframes, options) {\n        this.updateTarget(\"layout\", keyframes, options);\n        return this;\n    }\n    new(keyframes, options) {\n        this.updateTarget(\"new\", keyframes, options);\n        return this;\n    }\n    old(keyframes, options) {\n        this.updateTarget(\"old\", keyframes, options);\n        return this;\n    }\n    enter(keyframes, options) {\n        this.updateTarget(\"enter\", keyframes, options);\n        return this;\n    }\n    exit(keyframes, options) {\n        this.updateTarget(\"exit\", keyframes, options);\n        return this;\n    }\n    crossfade(options) {\n        this.updateTarget(\"enter\", { opacity: 1 }, options);\n        this.updateTarget(\"exit\", { opacity: 0 }, options);\n        return this;\n    }\n    updateTarget(target, keyframes, options = {}) {\n        const { currentTarget, targets } = this;\n        if (!targets.has(currentTarget)) {\n            targets.set(currentTarget, {});\n        }\n        const targetData = targets.get(currentTarget);\n        targetData[target] = { keyframes, options };\n    }\n    then(resolve, reject) {\n        return this.readyPromise.then(resolve, reject);\n    }\n}\nfunction view(update, defaultOptions = {}) {\n    return new ViewTransitionBuilder(update, defaultOptions);\n}\n\nexport { ViewTransitionBuilder, view };\n","import { isDragging } from './is-active.mjs';\n\nfunction setDragLock(axis) {\n    if (axis === \"x\" || axis === \"y\") {\n        if (isDragging[axis]) {\n            return null;\n        }\n        else {\n            isDragging[axis] = true;\n            return () => {\n                isDragging[axis] = false;\n            };\n        }\n    }\n    else {\n        if (isDragging.x || isDragging.y) {\n            return null;\n        }\n        else {\n            isDragging.x = isDragging.y = true;\n            return () => {\n                isDragging.x = isDragging.y = false;\n            };\n        }\n    }\n}\n\nexport { setDragLock };\n","export { GroupPlaybackControls } from './animation/controls/Group.mjs';\nexport { getValueTransition } from './animation/utils/get-value-transition.mjs';\nexport { calcGeneratorDuration, maxGeneratorDuration } from './animation/generators/utils/calc-duration.mjs';\nexport { createGeneratorEasing } from './animation/generators/utils/create-generator-easing.mjs';\nexport { isGenerator } from './animation/generators/utils/is-generator.mjs';\nexport { NativeAnimationControls } from './animation/waapi/NativeAnimationControls.mjs';\nexport { attachTimeline } from './animation/waapi/utils/attach-timeline.mjs';\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing } from './animation/waapi/utils/easing.mjs';\nexport { generateLinearEasing } from './animation/waapi/utils/linear.mjs';\nexport { hover } from './gestures/hover.mjs';\nexport { press } from './gestures/press/index.mjs';\nexport { capturePointer } from './gestures/utils/capture-pointer.mjs';\nexport { isBezierDefinition } from './utils/is-bezier-definition.mjs';\nexport { resolveElements } from './utils/resolve-elements.mjs';\nexport { supportsFlags } from './utils/supports/flags.mjs';\nexport { supportsLinearEasing } from './utils/supports/linear-easing.mjs';\nexport { supportsScrollTimeline } from './utils/supports/scroll-timeline.mjs';\nexport { ViewTransitionBuilder, view } from './view/index.mjs';\nexport { isDragActive, isDragging } from './gestures/drag/state/is-active.mjs';\nexport { setDragLock } from './gestures/drag/state/set-active.mjs';\nexport { isNodeOrChild } from './gestures/utils/is-node-or-child.mjs';\nexport { isPrimaryPointer } from './gestures/utils/is-primary-pointer.mjs';\n","import { noop } from './noop.mjs';\n\nlet warning = noop;\nlet invariant = noop;\nif (process.env.NODE_ENV !== \"production\") {\n    warning = (check, message) => {\n        if (!check && typeof console !== \"undefined\") {\n            console.warn(message);\n        }\n    };\n    invariant = (check, message) => {\n        if (!check) {\n            throw new Error(message);\n        }\n    };\n}\n\nexport { invariant, warning };\n","/*#__NO_SIDE_EFFECTS__*/\nfunction memo(callback) {\n    let result;\n    return () => {\n        if (result === undefined)\n            result = callback();\n        return result;\n    };\n}\n\nexport { memo };\n","/*\n  Progress within given range\n\n  Given a lower limit and an upper limit, we return the progress\n  (expressed as a number 0-1) represented by the given value, and\n  limit that progress to within 0-1.\n\n  @param [number]: Lower limit\n  @param [number]: Upper limit\n  @param [number]: Value to find progress within given range\n  @return [number]: Progress of value within range as expressed 0-1\n*/\n/*#__NO_SIDE_EFFECTS__*/\nconst progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\n/*#__NO_SIDE_EFFECTS__*/\nconst secondsToMilliseconds = (seconds) => seconds * 1000;\n/*#__NO_SIDE_EFFECTS__*/\nconst millisecondsToSeconds = (milliseconds) => milliseconds / 1000;\n\nexport { millisecondsToSeconds, secondsToMilliseconds };\n"],"names":["unsupportedEasingFunctions","anticipate","_easing_anticipate_mjs__WEBPACK_IMPORTED_MODULE_2__","L","backInOut","_easing_back_mjs__WEBPACK_IMPORTED_MODULE_3__","XL","circInOut","_easing_circ_mjs__WEBPACK_IMPORTED_MODULE_4__","X7","AcceleratedAnimation","_BaseAnimation_mjs__WEBPACK_IMPORTED_MODULE_5__","v","constructor","options","name","motionValue","element","keyframes","resolver","_render_dom_DOMKeyframesResolver_mjs__WEBPACK_IMPORTED_MODULE_6__","s","resolvedKeyframes","finalKeyframe","onKeyframesResolved","scheduleResolve","initPlayback","duration","times","ease","type","startTime","owner","current","motion_dom__WEBPACK_IMPORTED_MODULE_0__","Vc","key","xD","hR","onComplete","onUpdate","pregeneratedAnimation","pregenerateKeyframes","sampleAnimation","_MainThreadAnimation_mjs__WEBPACK_IMPORTED_MODULE_1__","repeat","delay","isGenerator","state","done","value","pregeneratedKeyframes","t","push","sample","undefined","length","animation","_waapi_index_mjs__WEBPACK_IMPORTED_MODULE_7__","h","calcStartTime","pendingTimeline","_F","onfinish","set","_waapi_utils_get_final_keyframe_mjs__WEBPACK_IMPORTED_MODULE_8__","$","cancel","resolveFinishedPromise","resolved","motion_utils__WEBPACK_IMPORTED_MODULE_9__","X","time","currentTime","newTime","w","speed","playbackRate","newSpeed","playState","attachTimeline","timeline","_resolved","motion_utils__WEBPACK_IMPORTED_MODULE_10__","Z","play","isStopped","updateFinishedPromise","pause","stop","sampleTime","setWithVelocity","onStop","complete","finish","supports","repeatDelay","repeatType","damping","HTMLElement","transformTemplate","getProps","_waapi_utils_supports_waapi_mjs__WEBPACK_IMPORTED_MODULE_11__","H","_utils_accelerated_values_mjs__WEBPACK_IMPORTED_MODULE_12__","has","isAnimatable","Array","isArray","complex","P","test","startsWith","BaseAnimation","autoplay","hasAttemptedResolve","createdAt","sync_time","now","resolvedAt","KeyframesResolver","m","velocity","canAnimate","originKeyframe","targetKeyframe","isOriginAnimatable","isTargetAnimatable","errors","K","hasKeyframesChanged","i","es","use_instant_transition_state","c","get_final_keyframe","resolvedAnimation","onPostResolved","then","resolve","reject","currentFinishedPromise","flatten","Promise","frameloopDriver","passTimestamp","timestamp","update","start","frameloop_frame","Wi","Pn","frameData","isProcessing","generators","decay","inertia","I","tween","F","spring","S","percentToProgress","percent","MainThreadAnimation","holdTime","cancelTime","playbackSpeed","pendingPlayState","teardown","KeyframeResolver$1","KeyframeResolver","e","Object","assign","keyframes$1","mapPercentToKeyframes","mirroredGenerator","generatorFactory","pipe","z","mix","C","generator","reverse","calculatedDuration","iI","resolvedDuration","totalDuration","animation_count","mainThread","tick","next","Math","min","round","timeWithoutDelay","isInDelayPhase","max","elapsed","frameGenerator","progress","currentIteration","floor","iterationProgress","clamp","u","isAnimationFinished","time_conversion","driver","hasChanged","isScheduled","resume","onPlay","_a","stopDriver","animateValue","acceleratedValues","Set","startWaapiAnimation","valueName","keyframeOptions","offset","easing","eB","_stats_buffer_mjs__WEBPACK_IMPORTED_MODULE_1__","f","_stats_animation_count_mjs__WEBPACK_IMPORTED_MODULE_2__","waapi","animate","fill","iterations","direction","finished","finally","isNotNull","getFinalKeyframe","filter","index","supportsWaapi","motion_utils__WEBPACK_IMPORTED_MODULE_0__","hasOwnProperty","call","Element","prototype","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","restDelta","restSpeed","timeReachedBoundary","spring$1","origin","isOutOfBounds","nearestBoundary","abs","amplitude","ideal","target","calcDelta","exp","calcLatest","applyFriction","delta","latest","checkCatchBoundary","_spring_index_mjs__WEBPACK_IMPORTED_MODULE_0__","_utils_velocity_mjs__WEBPACK_IMPORTED_MODULE_1__","stiffness","hasUpdatedFrame","keyframeValues","easingFunctions","is_easing_array","N","map","R","absoluteTimes","offsets_default","Y","o","mapTimeToKeyframe","interpolate","values","mZ","splice","springDefaults","mass","bounce","visualDuration","granular","default","minDuration","maxDuration","minDamping","maxDamping","findSpring","_defaults_mjs__WEBPACK_IMPORTED_MODULE_0__","D","envelope","derivative","motion_utils__WEBPACK_IMPORTED_MODULE_1__","motion_utils__WEBPACK_IMPORTED_MODULE_2__","dampingRatio","_utils_clamp_mjs__WEBPACK_IMPORTED_MODULE_3__","exponentialDecay","undampedFreq","safeMin","calcAngularFreq","pow","g","d","a","approximateRoot","initialGuess","result","isNaN","sqrt","durationKeys","physicsKeys","isSpringType","keys","some","optionsOrVisualDuration","_defaults_mjs__WEBPACK_IMPORTED_MODULE_1__","resolveSpring","isResolvedFromDuration","getSpringOptions","springOptions","root","PI","_utils_clamp_mjs__WEBPACK_IMPORTED_MODULE_2__","derived","_find_mjs__WEBPACK_IMPORTED_MODULE_3__","motion_utils__WEBPACK_IMPORTED_MODULE_4__","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","angularFreq","sin","cos","dampedAngularFreq","freqForT","sinh","cosh","currentVelocity","_utils_velocity_mjs__WEBPACK_IMPORTED_MODULE_5__","isBelowVelocityThreshold","isBelowDisplacementThreshold","toString","EO","wk","calcGeneratorVelocity","resolveValue","prevT","_utils_velocity_per_second_mjs__WEBPACK_IMPORTED_MODULE_0__","underDampedSpring","criticallyDampedSpring","keyframesTransition","getDefaultTransition","valueKey","keys_transform","G","animateMotionValue","transition","isHandoff","valueTransition","ev","getVelocity","isTransitionDefined","when","_delay","delayChildren","staggerChildren","staggerDirection","from","shouldSkip","GlobalConfig","skipAnimations","get","sP","y","animateTarget","visualElement","targetAndTransition","transitionOverride","transitionEnd","animations","animationTypeState","animationState","getState","getValue","latestValues","valueTarget","shouldBlockAnimation","protectedKeys","needsAnimating","shouldBlock","window","MotionHandoffAnimation","appearId","_optimized_appear_get_appear_id_mjs__WEBPACK_IMPORTED_MODULE_1__","_frameloop_frame_mjs__WEBPACK_IMPORTED_MODULE_2__","_value_use_will_change_add_will_change_mjs__WEBPACK_IMPORTED_MODULE_3__","_motion_value_mjs__WEBPACK_IMPORTED_MODULE_4__","shouldReduceMotion","_render_html_utils_keys_position_mjs__WEBPACK_IMPORTED_MODULE_5__","all","_render_utils_setters_mjs__WEBPACK_IMPORTED_MODULE_6__","animateVariant","variant","resolve_dynamic_variants","x","presenceContext","custom","getAnimation","visual_element_target","getChildAnimations","variantChildren","size","forwardDelay","animateChildren","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","forEach","child","notify","first","last","b","sortNodePosition","animateVisualElement","definition","resolvedDefinition","getOptimisedAppearId","props","_data_id_mjs__WEBPACK_IMPORTED_MODULE_0__","M","p","_back_mjs__WEBPACK_IMPORTED_MODULE_0__","G2","backOut","_cubic_bezier_mjs__WEBPACK_IMPORTED_MODULE_0__","_","backIn","_modifiers_reverse_mjs__WEBPACK_IMPORTED_MODULE_1__","_modifiers_mirror_mjs__WEBPACK_IMPORTED_MODULE_2__","circIn","acos","circOut","_modifiers_reverse_mjs__WEBPACK_IMPORTED_MODULE_0__","_modifiers_mirror_mjs__WEBPACK_IMPORTED_MODULE_1__","calcBezier","a1","a2","cubicBezier","mX1","mY1","mX2","mY2","getTForX","binarySubdivide","lowerBound","upperBound","currentX","currentT","aX","easeIn","easeOut","easeInOut","mirrorEasing","reverseEasing","isEasingArray","easingLookup","linear","_ease_mjs__WEBPACK_IMPORTED_MODULE_2__","YQ","Vv","_circ_mjs__WEBPACK_IMPORTED_MODULE_3__","Z7","Bn","_back_mjs__WEBPACK_IMPORTED_MODULE_4__","CG","_anticipate_mjs__WEBPACK_IMPORTED_MODULE_5__","easingDefinitionToFunction","qE","motion_utils__WEBPACK_IMPORTED_MODULE_6__","k","x1","y1","x2","y2","_cubic_bezier_mjs__WEBPACK_IMPORTED_MODULE_7__","addDomEvent","eventName","handler","passive","addEventListener","removeEventListener","extractEventInfo","event","point","pageX","pageY","addPointerInfo","DJ","clearTime","_frame_mjs__WEBPACK_IMPORTED_MODULE_0__","_utils_GlobalConfig_mjs__WEBPACK_IMPORTED_MODULE_1__","useManualTiming","performance","queueMicrotask","Feature","node","isMounted","shallowCompare","prev","prevLength","numVariantProps","variant_props","V","reversePriorityOrder","numAnimationTypes","createTypeState","isActive","prevResolvedValues","createState","whileInView","whileHover","whileTap","whileDrag","whileFocus","exit","AnimationFeature","createAnimationState","visual_element","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","context","getVariantContext","isControllingVariants","parent","initial","prop","is_variant_label","removedKeys","encounteredKeys","removedVariantIndex","Infinity","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","is_animation_controls","variantDidChange","shouldAnimateType","handledRemovedValues","definitionList","resolvedValues","reduce","allKeys","markToAnimate","delete","liveStyle","is_keyframes_target","add","blockInitialAnimation","fallbackAnimation","initialTransition","fallbackTarget","getBaseTarget","shouldAnimate","Boolean","setActive","setAnimateFunction","makeAnimator","reset","updateAnimationControlsSubscription","unmountControls","subscribe","mount","prevAnimate","prevProps","unmount","id","ExitAnimationFeature","arguments","isPresent","onExitComplete","prevIsPresent","prevPresenceContext","exitAnimation","register","handleHoverEvent","lifecycle","callback","postRender","event_info","Q","HoverGesture","Mr","_element","startEvent","endEvent","FocusGesture","onFocus","isFocusVisible","matches","onBlur","add_dom_event","E","handlePressEvent","HTMLButtonElement","disabled","PressGesture","OD","success","useGlobalTarget","globalTapTarget","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","thresholdNames","InViewFeature","hasEnteredView","isInView","startObserver","viewport","margin","rootMargin","amount","once","threshold","observeIntersection","rootInteresectionObserver","initIntersectionObserver","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","observe","unobserve","isIntersecting","onViewportEnter","onViewportLeave","hasViewportOptionChanged","prevViewport","gestureAnimations","inView","tap","focus","hover","convertBoundingBoxToBox","top","left","right","bottom","convertBoxToBoundingBox","transformBoxPoints","transformPoint","topLeft","bottomRight","scalePoint","scale","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","axis","applyBoxDelta","box","applyTreeDeltas","treeScale","treePath","isSharedTransition","treeLength","projectionDelta","style","display","layoutScroll","scroll","transformBox","_utils_has_transform_mjs__WEBPACK_IMPORTED_MODULE_0__","ud","translateAxis","distance","transformAxis","axisTranslate","axisScale","axisOrigin","_utils_mix_number_mjs__WEBPACK_IMPORTED_MODULE_1__","transform","scaleX","originX","scaleY","originY","createAxisDelta","createDelta","createAxis","createBox","isIdentityScale","hasScale","hasTransform","has2DTranslate","rotate","rotateX","rotateY","skewX","skewY","is2DTranslate","measureViewportBox","instance","_geometry_conversion_mjs__WEBPACK_IMPORTED_MODULE_0__","i8","d7","getBoundingClientRect","measurePageBox","rootProjectionNode","transformPagePoint","viewportBox","_geometry_delta_apply_mjs__WEBPACK_IMPORTED_MODULE_1__","am","valueTypes","dimensions","color","findValueType","find","l","propEventHandlers","VisualElement","scrapeMotionValuesFromProps","_props","_prevProps","_visualElement","reducedMotionConfig","visualState","children","isVariantNode","Map","features","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","render","triggerBuild","renderInstance","renderState","projection","renderScheduledAt","scheduleRender","baseTarget","initialValues","depth","is_controlling_variants","willChange","initialMotionValues","is_motion_value","store","removeFromVariantTree","addVariantChild","bindToMotionValue","O","reduced_motion","A","n","remove","clear","feature","removeSyncCheck","valueIsTransform","onBindTransform","removeOnChange","on","latestValue","preRender","isTransformDirty","removeOnRenderRequest","MotionCheckAppearSync","other","sortInstanceNodePosition","updateFeatures","definitions","featureDefinitions","featureDefinition","isEnabled","FeatureConstructor","build","measureInstanceViewportBox","models","dO","getStaticValue","setStaticValue","listener","updateMotionValuesFromProps","nextValue","prevValue","addValue","es_value","BX","hasValue","existingValue","jump","hasAnimated","removeValue","handleChildMotionValue","getVariant","variants","getTransformPagePoint","getClosestVariantNode","closestVariantNode","unsubscribe","removeValueFromRenderState","defaultValue","readValue","getBaseTargetFromProps","readValueFromInstance","is_numerical_string","is_zero_value_string","W","parseFloat","animatable_none","T","setBaseTarget","valueFromInitial","resolve_variants","subscription_manager","args","invalidTemplates","splitCSSVariableRegex","DOMKeyframesResolver","unresolvedKeyframes","readKeyframes","keyframe","trim","is_css_variable","getVariableValue","token","fallback","parseCSSVariable","match","exec","token1","token2","getComputedStyle","getPropertyValue","trimmed","resolveNoneKeyframes","keys_position","originType","targetType","unit_conversion","mP","needsMeasurement","noneKeyframeIndexes","makeNoneKeyframesAnimatable","animatableTemplate","noneIndex","measureInitialState","suspendedScrollY","pageYOffset","measuredOrigin","lw","measureKeyframe","measureEndState","finalKeyframeIndex","removedTransforms","unsetTransformName","unsetTransformValue","DOMVisualElement","_VisualElement_mjs__WEBPACK_IMPORTED_MODULE_0__","_DOMKeyframesResolver_mjs__WEBPACK_IMPORTED_MODULE_1__","compareDocumentPosition","vars","childSubscription","_value_utils_is_motion_value_mjs__WEBPACK_IMPORTED_MODULE_2__","textContent","createDomVisualElement","Component","_utils_is_svg_component_mjs__WEBPACK_IMPORTED_MODULE_1__","q","_svg_SVGVisualElement_mjs__WEBPACK_IMPORTED_MODULE_2__","_html_HTMLVisualElement_mjs__WEBPACK_IMPORTED_MODULE_3__","allowProjection","react__WEBPACK_IMPORTED_MODULE_0__","Fragment","domAnimation","renderer","_create_visual_element_mjs__WEBPACK_IMPORTED_MODULE_0__","_motion_features_animations_mjs__WEBPACK_IMPORTED_MODULE_1__","_motion_features_gestures_mjs__WEBPACK_IMPORTED_MODULE_2__","isNumOrPxType","_value_types_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_0__","Rx","_value_types_numbers_units_mjs__WEBPACK_IMPORTED_MODULE_1__","px","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","_html_utils_keys_transform_mjs__WEBPACK_IMPORTED_MODULE_2__","removeNonTranslationalTransform","positionalValues","width","paddingLeft","paddingRight","height","paddingTop","paddingBottom","translateX","translateY","getAnimatableNone","defaultValueType","_value_types_complex_filter_mjs__WEBPACK_IMPORTED_MODULE_1__","_value_types_complex_index_mjs__WEBPACK_IMPORTED_MODULE_2__","defaultValueTypes","_number_mjs__WEBPACK_IMPORTED_MODULE_0__","j","_value_types_color_index_mjs__WEBPACK_IMPORTED_MODULE_1__","backgroundColor","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","_value_types_complex_filter_mjs__WEBPACK_IMPORTED_MODULE_2__","WebkitFilter","getDefaultValueType","dimensionValueTypes","numbers","units","aQ","RW","vw","vh","parse","findDimensionValueType","testValueType","HTMLVisualElement","_dom_DOMVisualElement_mjs__WEBPACK_IMPORTED_MODULE_0__","J","_utils_render_mjs__WEBPACK_IMPORTED_MODULE_1__","_utils_keys_transform_mjs__WEBPACK_IMPORTED_MODULE_2__","defaultType","_dom_value_types_defaults_mjs__WEBPACK_IMPORTED_MODULE_3__","computedStyle","_dom_utils_is_css_variable_mjs__WEBPACK_IMPORTED_MODULE_4__","_projection_utils_measure_mjs__WEBPACK_IMPORTED_MODULE_5__","_utils_build_styles_mjs__WEBPACK_IMPORTED_MODULE_6__","r","_utils_scrape_motion_values_mjs__WEBPACK_IMPORTED_MODULE_7__","U","positionalKeys","_keys_transform_mjs__WEBPACK_IMPORTED_MODULE_0__","visualElementStore","SVGVisualElement","isSVGTag","_projection_geometry_models_mjs__WEBPACK_IMPORTED_MODULE_1__","updateDimensions","_utils_measure_mjs__WEBPACK_IMPORTED_MODULE_2__","_html_utils_keys_transform_mjs__WEBPACK_IMPORTED_MODULE_3__","_dom_value_types_defaults_mjs__WEBPACK_IMPORTED_MODULE_4__","_dom_utils_camel_to_dash_mjs__WEBPACK_IMPORTED_MODULE_6__","getAttribute","_frameloop_frame_mjs__WEBPACK_IMPORTED_MODULE_8__","_utils_build_attrs_mjs__WEBPACK_IMPORTED_MODULE_9__","styleProp","_utils_render_mjs__WEBPACK_IMPORTED_MODULE_10__","_utils_is_svg_tag_mjs__WEBPACK_IMPORTED_MODULE_11__","tagName","toResolve","anyNeedsMeasurement","measureAllKeyframes","resolversToMeasure","elementsToMeasure","transformsToRestore","_dom_utils_unit_conversion_mjs__WEBPACK_IMPORTED_MODULE_0__","Ei","restore","scrollTo","readAllKeyframes","flushKeyframeResolvers","isAsync","isComplete","_frameloop_frame_mjs__WEBPACK_IMPORTED_MODULE_1__","read","resolveKeyframes","currentValue","valueAsRead","setFinalKeyframe","renderEndStyles","resolveVariant","_resolve_variants_mjs__WEBPACK_IMPORTED_MODULE_0__","setTarget","_resolve_dynamic_variants_mjs__WEBPACK_IMPORTED_MODULE_1__","_utils_resolve_value_mjs__WEBPACK_IMPORTED_MODULE_2__","_value_index_mjs__WEBPACK_IMPORTED_MODULE_0__","activeAnimations","layout","addUniqueItem","arr","item","indexOf","removeItem","moveItem","fromIndex","toIndex","startIndex","endIndex","input","output","isClamp","mixer","inputLength","motion_utils__WEBPACK_IMPORTED_MODULE_3__","isZeroDeltaRange","mixers","createMixers","customMixer","mixerFactory","_mix_index_mjs__WEBPACK_IMPORTED_MODULE_0__","numMixers","easingFunction","_pipe_mjs__WEBPACK_IMPORTED_MODULE_2__","interpolator","progressInRange","_clamp_mjs__WEBPACK_IMPORTED_MODULE_5__","isNumericalString","isZeroValueString","hueToRgb","mixImmediate","mixLinearColor","to","fromExpo","expo","colorTypes","hex","rgba","hsla","getColorType","asRGBA","model","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","mixColor","fromRGBA","toRGBA","blended","number","invisibleValues","mixNumber","getMixer","mixComplex","mixArray","mixObject","numValues","blendValue","template","createTransformer","originStats","targetStats","indexes","var","matchOrder","orderedOrigin","pointers","types","originIndex","originValue","defaultOffset","_fill_mjs__WEBPACK_IMPORTED_MODULE_0__","fillOffset","remaining","offsetProgress","_mix_number_mjs__WEBPACK_IMPORTED_MODULE_1__","combineFunctions","transformers","initPrefersReducedMotion","_state_mjs__WEBPACK_IMPORTED_MODULE_0__","_is_browser_mjs__WEBPACK_IMPORTED_MODULE_1__","matchMedia","motionMediaQuery","setReducedMotionPreferences","addListener","prefersReducedMotion","hasReducedMotionListener","SubscriptionManager","subscriptions","_array_mjs__WEBPACK_IMPORTED_MODULE_0__","y4","cl","numSubscriptions","getSize","instantAnimationState","velocityPerSecond","frameDuration","isFloat","collectMotionValues","MotionValue","init","version","canTrackVelocity","updateAndNotify","_frameloop_sync_time_mjs__WEBPACK_IMPORTED_MODULE_0__","updatedAt","setPrevFrameValue","setCurrent","change","renderRequest","prevFrameValue","prevUpdatedAt","onChange","subscription","_utils_subscription_manager_mjs__WEBPACK_IMPORTED_MODULE_1__","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","endAnimation","getPrevious","_utils_velocity_per_second_mjs__WEBPACK_IMPORTED_MODULE_3__","startAnimation","animationStart","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","_utils_mjs__WEBPACK_IMPORTED_MODULE_0__","substring","parseInt","_rgba_mjs__WEBPACK_IMPORTED_MODULE_1__","alpha$1","_numbers_units_mjs__WEBPACK_IMPORTED_MODULE_1__","_utils_sanitize_mjs__WEBPACK_IMPORTED_MODULE_2__","_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_3__","Fq","_rgba_mjs__WEBPACK_IMPORTED_MODULE_0__","_hex_mjs__WEBPACK_IMPORTED_MODULE_1__","_hsla_mjs__WEBPACK_IMPORTED_MODULE_2__","clampRgbUnit","_utils_clamp_mjs__WEBPACK_IMPORTED_MODULE_0__","rgbUnit","_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_1__","_utils_mjs__WEBPACK_IMPORTED_MODULE_2__","_utils_sanitize_mjs__WEBPACK_IMPORTED_MODULE_3__","singleColorRegex","isColorString","testProp","splitColor","aName","bName","cName","float_regex","maxDefaults","applyDefaultFilter","slice","_utils_float_regex_mjs__WEBPACK_IMPORTED_MODULE_0__","unit","replace","functionRegex","_index_mjs__WEBPACK_IMPORTED_MODULE_1__","functions","join","colorRegex","NUMBER_TOKEN","COLOR_TOKEN","complexRegex","analyseComplexValue","originalValue","tokenised","parsedValue","parseComplexValue","source","numSections","sanitize","convertNumbersToZero","_b","parsed","transformer","floatRegex","addValueToWillChange","easing_mapEasingToNativeEasing","supportsLinearEasing","generateLinearEasing","isBezierDefinition","cubicBezierAsString","segmentEasing","supportedWaapiEasing","supportsScrollTimeline","memo","ScrollTimeline","BaseGroup_BaseGroupPlaybackControls","runAll","getAll","propName","setAll","newValue","methodName","controls","GroupPlaybackControls","onResolve","onReject","catch","get_value_transition_getValueTransition","maxGeneratorDuration","calcGeneratorDuration","createGeneratorEasing","createGenerator","NativeAnimationControls_NativeAnimationControls","_c","durationInMs","effect","getComputedTiming","Number","commitStyles","updateTiming","es_noop","supportsFlags","linearEasing","memoSupports","supportsFlag","memoized","createElement","opacity","resolution","points","numPoints","isWaapiSupportedEasing","every","isDragging","isDragActive","resolveElements","elementOrSelector","scope","selectorCache","EventTarget","elements","querySelectorAll","setupGesture","gestureAbortController","AbortController","signal","abort","isValidHover","pointerType","onHoverStart","eventOptions","onPointerEnter","enterEvent","onHoverEnd","onPointerLeave","leaveEvent","capturePointer","action","actionName","pointerId","isNodeOrChild","parentElement","isPrimaryPointer","button","isPrimary","focusableElements","isPressing","WeakSet","filterEvents","firePointerEvent","dispatchEvent","PointerEvent","bubbles","enableKeyboardPress","focusEvent","currentTarget","handleKeydown","handleKeyup","press","targetOrSelector","onPressStart","targets","cancelEvents","startPress","onPressEnd","onPointerEnd","onPointerUp","onPointerCancel","rect","upEvent","isTrusted","innerWidth","innerHeight","clientX","clientY","cancelEvent","canAddKeyboardAccessibility","tabIndex","setDragLock","warning","_noop_mjs__WEBPACK_IMPORTED_MODULE_0__","invariant","toFromDifference","secondsToMilliseconds","seconds","millisecondsToSeconds","milliseconds"],"sourceRoot":""}