@scbt-ecom/ui 0.93.0 → 0.95.0

package/dist/node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.js.map

@@ -1 +1 @@
-{"version":3,"file":"AcceleratedAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.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"],"names":["sampleDelta","maxDuration","requiresPregeneratedKeyframes","options","isGenerator","isWaapiSupportedEasing","pregenerateKeyframes","keyframes","sampleAnimation","MainThreadAnimation","state","pregeneratedKeyframes","t","unsupportedEasingFunctions","anticipate","backInOut","circInOut","isUnsupportedEase","key","AcceleratedAnimation","BaseAnimation","name","motionValue","element","DOMKeyframesResolver","resolvedKeyframes","finalKeyframe","duration","times","ease","type","startTime","supportsLinearEasing","onComplete","onUpdate","pregeneratedAnimation","animation","startWaapiAnimation","attachTimeline","getFinalKeyframe","resolved","millisecondsToSeconds","newTime","secondsToMilliseconds","newSpeed","timeline","noop","sampleTime","onStop","repeatDelay","repeatType","damping","transformTemplate","supportsWaapi","acceleratedValues"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"AcceleratedAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.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"],"names":["sampleDelta","maxDuration","requiresPregeneratedKeyframes","options","isGenerator","isWaapiSupportedEasing","pregenerateKeyframes","keyframes","sampleAnimation","MainThreadAnimation","state","pregeneratedKeyframes","t","unsupportedEasingFunctions","anticipate","backInOut","circInOut","isUnsupportedEase","key","AcceleratedAnimation","BaseAnimation","name","motionValue","element","DOMKeyframesResolver","resolvedKeyframes","finalKeyframe","duration","times","ease","type","startTime","supportsLinearEasing","onComplete","onUpdate","pregeneratedAnimation","animation","startWaapiAnimation","attachTimeline","getFinalKeyframe","resolved","millisecondsToSeconds","newTime","secondsToMilliseconds","newSpeed","timeline","noop","sampleTime","onStop","repeatDelay","repeatType","damping","transformTemplate","supportsWaapi","acceleratedValues"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.js.map

@@ -1 +1 @@
-{"version":3,"file":"BaseAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs"],"sourcesContent":["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"],"names":["MAX_RESOLVE_DELAY","BaseAnimation","autoplay","delay","type","repeat","repeatDelay","repeatType","options","time","flushKeyframeResolvers","keyframes","finalKeyframe","name","velocity","onComplete","onUpdate","isGenerator","canAnimate","getFinalKeyframe","resolvedAnimation","resolve","reject"],"mappings":"gQAcA,MAAMA,EAAoB,GAC1B,MAAMC,CAAc,CAChB,YAAY,CAAE,SAAAC,EAAW,GAAM,MAAAC,EAAQ,EAAG,KAAAC,EAAO,YAAa,OAAAC,EAAS,EAAG,YAAAC,EAAc,EAAG,WAAAC,EAAa,OAAQ,GAAGC,GAAW,CAE1H,KAAK,UAAY,GACjB,KAAK,oBAAsB,GAC3B,KAAK,UAAYC,EAAK,IAAG,EACzB,KAAK,QAAU,CACX,SAAAP,EACA,MAAAC,EACA,KAAAC,EACA,OAAAC,EACA,YAAAC,EACA,WAAAC,EACA,GAAGC,CACf,EACQ,KAAK,sBAAqB,CAClC,CAWI,eAAgB,CACZ,OAAK,KAAK,WAEH,KAAK,WAAa,KAAK,UAAYR,EACpC,KAAK,WACL,KAAK,UAHA,KAAK,SAIxB,CAMI,IAAI,UAAW,CACX,MAAI,CAAC,KAAK,WAAa,CAAC,KAAK,qBACzBU,EAAsB,EAEnB,KAAK,SACpB,CAMI,oBAAoBC,EAAWC,EAAe,CAC1C,KAAK,WAAaH,EAAK,IAAG,EAC1B,KAAK,oBAAsB,GAC3B,KAAM,CAAE,KAAAI,EAAM,KAAAT,EAAM,SAAAU,EAAU,MAAAX,EAAO,WAAAY,EAAY,SAAAC,EAAU,YAAAC,GAAiB,KAAK,QAKjF,GAAI,CAACA,GAAe,CAACC,EAAWP,EAAWE,EAAMT,EAAMU,CAAQ,EAE3D,GAAsCX,EASlC,KAAK,QAAQ,SAAW,MATiB,CACzCa,GACIA,EAASG,EAAiBR,EAAW,KAAK,QAASC,CAAa,CAAC,EACrEG,GAAcA,EAAU,EACxB,KAAK,uBAAsB,EAC3B,MAChB,CAMQ,MAAMK,EAAoB,KAAK,aAAaT,EAAWC,CAAa,EAChEQ,IAAsB,KAE1B,KAAK,UAAY,CACb,UAAAT,EACA,cAAAC,EACA,GAAGQ,CACf,EACQ,KAAK,eAAc,EAC3B,CACI,gBAAiB,CAAA,CAMjB,KAAKC,EAASC,EAAQ,CAClB,OAAO,KAAK,uBAAuB,KAAKD,EAASC,CAAM,CAC/D,CACI,SAAU,CACN,KAAK,QAAQ,KAAO,YACpB,KAAK,QAAQ,KAAO,QAC5B,CACI,uBAAwB,CACpB,KAAK,uBAAyB,IAAI,QAASD,GAAY,CACnD,KAAK,uBAAyBA,CAC1C,CAAS,CACT,CACA","x_google_ignoreList":[0]}
+{"version":3,"file":"BaseAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs"],"sourcesContent":["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"],"names":["MAX_RESOLVE_DELAY","BaseAnimation","autoplay","delay","type","repeat","repeatDelay","repeatType","options","time","flushKeyframeResolvers","keyframes","finalKeyframe","name","velocity","onComplete","onUpdate","isGenerator","canAnimate","getFinalKeyframe","resolvedAnimation","resolve","reject"],"mappings":"gQAcA,MAAMA,EAAoB,GAC1B,MAAMC,CAAc,CAChB,YAAY,CAAE,SAAAC,EAAW,GAAM,MAAAC,EAAQ,EAAG,KAAAC,EAAO,YAAa,OAAAC,EAAS,EAAG,YAAAC,EAAc,EAAG,WAAAC,EAAa,OAAQ,GAAGC,GAAW,CAE1H,KAAK,UAAY,GACjB,KAAK,oBAAsB,GAC3B,KAAK,UAAYC,EAAK,IAAG,EACzB,KAAK,QAAU,CACX,SAAAP,EACA,MAAAC,EACA,KAAAC,EACA,OAAAC,EACA,YAAAC,EACA,WAAAC,EACA,GAAGC,CACf,EACQ,KAAK,sBAAqB,CAC9B,CAWA,eAAgB,CACZ,OAAK,KAAK,WAEH,KAAK,WAAa,KAAK,UAAYR,EACpC,KAAK,WACL,KAAK,UAHA,KAAK,SAIpB,CAMA,IAAI,UAAW,CACX,MAAI,CAAC,KAAK,WAAa,CAAC,KAAK,qBACzBU,EAAsB,EAEnB,KAAK,SAChB,CAMA,oBAAoBC,EAAWC,EAAe,CAC1C,KAAK,WAAaH,EAAK,IAAG,EAC1B,KAAK,oBAAsB,GAC3B,KAAM,CAAE,KAAAI,EAAM,KAAAT,EAAM,SAAAU,EAAU,MAAAX,EAAO,WAAAY,EAAY,SAAAC,EAAU,YAAAC,GAAiB,KAAK,QAKjF,GAAI,CAACA,GAAe,CAACC,EAAWP,EAAWE,EAAMT,EAAMU,CAAQ,EAE3D,GAAsCX,EASlC,KAAK,QAAQ,SAAW,MATiB,CACzCa,GACIA,EAASG,EAAiBR,EAAW,KAAK,QAASC,CAAa,CAAC,EACrEG,GAAcA,EAAU,EACxB,KAAK,uBAAsB,EAC3B,MACJ,CAMJ,MAAMK,EAAoB,KAAK,aAAaT,EAAWC,CAAa,EAChEQ,IAAsB,KAE1B,KAAK,UAAY,CACb,UAAAT,EACA,cAAAC,EACA,GAAGQ,CACf,EACQ,KAAK,eAAc,EACvB,CACA,gBAAiB,CAAE,CAMnB,KAAKC,EAASC,EAAQ,CAClB,OAAO,KAAK,uBAAuB,KAAKD,EAASC,CAAM,CAC3D,CACA,SAAU,CACN,KAAK,QAAQ,KAAO,YACpB,KAAK,QAAQ,KAAO,QACxB,CACA,uBAAwB,CACpB,KAAK,uBAAyB,IAAI,QAASD,GAAY,CACnD,KAAK,uBAAyBA,CAClC,CAAC,CACL,CACJ","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.js.map

@@ -1 +1 @@
-{"version":3,"file":"MainThreadAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs"],"sourcesContent":["import { isGenerator, calcGeneratorDuration } from 'motion-dom';\nimport { invariant, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { KeyframeResolver } from '../../render/utils/KeyframesResolver.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 (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            if (process.env.NODE_ENV !== \"production\") {\n                invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n            }\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        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    }\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"],"names":["generators","inertia","keyframes","spring","percentToProgress","percent","MainThreadAnimation","BaseAnimation","options","onStop","name","motionValue","element","KeyframeResolver$1","KeyframeResolver","onResolved","resolvedKeyframes","finalKeyframe","keyframes$1","type","repeat","repeatDelay","repeatType","velocity","generatorFactory","isGenerator","mapPercentToKeyframes","mirroredGenerator","pipe","mix","generator","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","autoplay","timestamp","sample","resolved","delay","onUpdate","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","clamp","state","done","isAnimationFinished","getFinalKeyframe","millisecondsToSeconds","newTime","secondsToMilliseconds","newSpeed","hasChanged","driver","frameloopDriver","onPlay","startTime","now","_a","onComplete","time"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"MainThreadAnimation.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs"],"sourcesContent":["import { isGenerator, calcGeneratorDuration } from 'motion-dom';\nimport { invariant, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { KeyframeResolver } from '../../render/utils/KeyframesResolver.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 (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            if (process.env.NODE_ENV !== \"production\") {\n                invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n            }\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        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    }\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"],"names":["generators","inertia","keyframes","spring","percentToProgress","percent","MainThreadAnimation","BaseAnimation","options","onStop","name","motionValue","element","KeyframeResolver$1","KeyframeResolver","onResolved","resolvedKeyframes","finalKeyframe","keyframes$1","type","repeat","repeatDelay","repeatType","velocity","generatorFactory","isGenerator","mapPercentToKeyframes","mirroredGenerator","pipe","mix","generator","calcGeneratorDuration","calculatedDuration","resolvedDuration","totalDuration","autoplay","timestamp","sample","resolved","delay","onUpdate","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","clamp","state","done","isAnimationFinished","getFinalKeyframe","millisecondsToSeconds","newTime","secondsToMilliseconds","newSpeed","hasChanged","driver","frameloopDriver","onPlay","startTime","now","_a","onComplete","time"],"mappings":"w4BAaA,MAAMA,EAAa,CACf,MAAOC,EACP,QAAAA,EACA,MAAOC,EACP,UAAAA,EACA,OAAAC,CACJ,EACMC,EAAqBC,GAAYA,EAAU,IAMjD,MAAMC,WAA4BC,CAAc,CAC5C,YAAYC,EAAS,CACjB,MAAMA,CAAO,EAIb,KAAK,SAAW,KAIhB,KAAK,WAAa,KAIlB,KAAK,YAAc,EAInB,KAAK,cAAgB,EAMrB,KAAK,iBAAmB,UAIxB,KAAK,UAAY,KACjB,KAAK,MAAQ,OAKb,KAAK,KAAO,IAAM,CAGd,GAFA,KAAK,SAAS,OAAA,EACd,KAAK,UAAY,GACb,KAAK,QAAU,OACf,OACJ,KAAK,SAAA,EACL,KAAM,CAAE,OAAAC,GAAW,KAAK,QACxBA,GAAUA,EAAA,CACd,EACA,KAAM,CAAE,KAAAC,EAAM,YAAAC,EAAa,QAAAC,EAAS,UAAAV,CAAAA,EAAc,KAAK,QACjDW,GAAsBD,GAAY,KAA6B,OAASA,EAAQ,mBAAqBE,EACrGC,EAAa,CAACC,EAAmBC,IAAkB,KAAK,oBAAoBD,EAAmBC,CAAa,EAClH,KAAK,SAAW,IAAIJ,EAAmBX,EAAWa,EAAYL,EAAMC,EAAaC,CAAO,EACxF,KAAK,SAAS,gBAAA,CAClB,CACA,SAAU,CACN,MAAM,QAAA,EAEF,KAAK,WACL,OAAO,OAAO,KAAK,UAAW,KAAK,aAAa,KAAK,UAAU,SAAS,CAAC,CAEjF,CACA,aAAaM,EAAa,CACtB,KAAM,CAAE,KAAAC,EAAO,YAAa,OAAAC,EAAS,EAAG,YAAAC,EAAc,EAAG,WAAAC,EAAY,SAAAC,EAAW,CAAA,EAAO,KAAK,QACtFC,EAAmBC,EAAYN,CAAI,EACnCA,EACAnB,EAAWmB,CAAI,GAAKjB,EAO1B,IAAIwB,EACAC,EACAH,IAAqBtB,GACrB,OAAOgB,EAAY,CAAC,GAAM,WAI1BQ,EAAwBE,EAAKxB,EAAmByB,EAAIX,EAAY,CAAC,EAAGA,EAAY,CAAC,CAAC,CAAC,EACnFA,EAAc,CAAC,EAAG,GAAG,GAEzB,MAAMY,EAAYN,EAAiB,CAAE,GAAG,KAAK,QAAS,UAAWN,EAAa,EAK1EI,IAAe,WACfK,EAAoBH,EAAiB,CACjC,GAAG,KAAK,QACR,UAAW,CAAC,GAAGN,CAAW,EAAE,QAAA,EAC5B,SAAU,CAACK,CAAA,CACd,GAUDO,EAAU,qBAAuB,OACjCA,EAAU,mBAAqBC,EAAsBD,CAAS,GAElE,KAAM,CAAE,mBAAAE,GAAuBF,EACzBG,EAAmBD,EAAqBX,EACxCa,EAAgBD,GAAoBb,EAAS,GAAKC,EACxD,MAAO,CACH,UAAAS,EACA,kBAAAH,EACA,sBAAAD,EACA,mBAAAM,EACA,iBAAAC,EACA,cAAAC,CAAA,CAER,CACA,gBAAiB,CACb,KAAM,CAAE,SAAAC,EAAW,EAAA,EAAS,KAAK,QACjC,KAAK,KAAA,EACD,KAAK,mBAAqB,UAAY,CAACA,EACvC,KAAK,MAAA,EAGL,KAAK,MAAQ,KAAK,gBAE1B,CACA,KAAKC,EAAWC,EAAS,GAAO,CAC5B,KAAM,CAAE,SAAAC,GAAa,KAErB,GAAI,CAACA,EAAU,CACX,KAAM,CAAE,UAAApC,CAAAA,EAAc,KAAK,QAC3B,MAAO,CAAE,KAAM,GAAM,MAAOA,EAAUA,EAAU,OAAS,CAAC,CAAA,CAC9D,CACA,KAAM,CAAE,cAAAe,EAAe,UAAAa,EAAW,kBAAAH,EAAmB,sBAAAD,EAAuB,UAAAxB,EAAW,mBAAA8B,EAAoB,cAAAE,EAAe,iBAAAD,CAAA,EAAsBK,EAChJ,GAAI,KAAK,YAAc,KACnB,OAAOR,EAAU,KAAK,CAAC,EAC3B,KAAM,CAAE,MAAAS,EAAO,OAAAnB,EAAQ,WAAAE,EAAY,YAAAD,EAAa,SAAAmB,CAAA,EAAa,KAAK,QAO9D,KAAK,MAAQ,EACb,KAAK,UAAY,KAAK,IAAI,KAAK,UAAWJ,CAAS,EAE9C,KAAK,MAAQ,IAClB,KAAK,UAAY,KAAK,IAAIA,EAAYF,EAAgB,KAAK,MAAO,KAAK,SAAS,GAGhFG,EACA,KAAK,YAAcD,EAEd,KAAK,WAAa,KACvB,KAAK,YAAc,KAAK,SAMxB,KAAK,YACD,KAAK,MAAMA,EAAY,KAAK,SAAS,EAAI,KAAK,MAGtD,MAAMK,EAAmB,KAAK,YAAcF,GAAS,KAAK,OAAS,EAAI,EAAI,IACrEG,EAAiB,KAAK,OAAS,EAC/BD,EAAmB,EACnBA,EAAmBP,EACzB,KAAK,YAAc,KAAK,IAAIO,EAAkB,CAAC,EAE3C,KAAK,QAAU,YAAc,KAAK,WAAa,OAC/C,KAAK,YAAcP,GAEvB,IAAIS,EAAU,KAAK,YACfC,EAAiBd,EACrB,GAAIV,EAAQ,CAMR,MAAMyB,EAAW,KAAK,IAAI,KAAK,YAAaX,CAAa,EAAID,EAK7D,IAAIa,EAAmB,KAAK,MAAMD,CAAQ,EAKtCE,EAAoBF,EAAW,EAK/B,CAACE,GAAqBF,GAAY,IAClCE,EAAoB,GAExBA,IAAsB,GAAKD,IAC3BA,EAAmB,KAAK,IAAIA,EAAkB1B,EAAS,CAAC,EAIjC,GAAQ0B,EAAmB,KAE1CxB,IAAe,WACfyB,EAAoB,EAAIA,EACpB1B,IACA0B,GAAqB1B,EAAcY,IAGlCX,IAAe,WACpBsB,EAAiBjB,IAGzBgB,EAAUK,EAAM,EAAG,EAAGD,CAAiB,EAAId,CAC/C,CAMA,MAAMgB,EAAQP,EACR,CAAE,KAAM,GAAO,MAAOxC,EAAU,CAAC,CAAA,EACjC0C,EAAe,KAAKD,CAAO,EAC7BjB,IACAuB,EAAM,MAAQvB,EAAsBuB,EAAM,KAAK,GAEnD,GAAI,CAAE,KAAAC,GAASD,EACX,CAACP,GAAkBV,IAAuB,OAC1CkB,EACI,KAAK,OAAS,EACR,KAAK,aAAehB,EACpB,KAAK,aAAe,GAElC,MAAMiB,EAAsB,KAAK,WAAa,OACzC,KAAK,QAAU,YAAe,KAAK,QAAU,WAAaD,GAC/D,OAAIC,GAAuBlC,IAAkB,SACzCgC,EAAM,MAAQG,EAAiBlD,EAAW,KAAK,QAASe,CAAa,GAErEuB,GACAA,EAASS,EAAM,KAAK,EAEpBE,GACA,KAAK,OAAA,EAEFF,CACX,CACA,IAAI,UAAW,CACX,KAAM,CAAE,SAAAX,GAAa,KACrB,OAAOA,EAAWe,EAAsBf,EAAS,kBAAkB,EAAI,CAC3E,CACA,IAAI,MAAO,CACP,OAAOe,EAAsB,KAAK,WAAW,CACjD,CACA,IAAI,KAAKC,EAAS,CACdA,EAAUC,EAAsBD,CAAO,EACvC,KAAK,YAAcA,EACf,KAAK,WAAa,MAAQ,KAAK,QAAU,EACzC,KAAK,SAAWA,EAEX,KAAK,SACV,KAAK,UAAY,KAAK,OAAO,MAAQA,EAAU,KAAK,MAE5D,CACA,IAAI,OAAQ,CACR,OAAO,KAAK,aAChB,CACA,IAAI,MAAME,EAAU,CAChB,MAAMC,EAAa,KAAK,gBAAkBD,EAC1C,KAAK,cAAgBA,EACjBC,IACA,KAAK,KAAOJ,EAAsB,KAAK,WAAW,EAE1D,CACA,MAAO,CAIH,GAHK,KAAK,SAAS,aACf,KAAK,SAAS,OAAA,EAEd,CAAC,KAAK,UAAW,CACjB,KAAK,iBAAmB,UACxB,MACJ,CACA,GAAI,KAAK,UACL,OACJ,KAAM,CAAE,OAAAK,EAASC,EAAiB,OAAAC,EAAQ,UAAAC,CAAA,EAAc,KAAK,QACxD,KAAK,SACN,KAAK,OAASH,EAAQtB,GAAc,KAAK,KAAKA,CAAS,CAAC,GAE5DwB,GAAUA,EAAA,EACV,MAAME,EAAM,KAAK,OAAO,IAAA,EACpB,KAAK,WAAa,KAClB,KAAK,UAAYA,EAAM,KAAK,SAEtB,KAAK,UAGN,KAAK,QAAU,aACpB,KAAK,UAAYA,GAHjB,KAAK,UAAYD,GAAyD,KAAK,cAAA,EAK/E,KAAK,QAAU,YACf,KAAK,sBAAA,EAET,KAAK,WAAa,KAAK,UACvB,KAAK,SAAW,KAKhB,KAAK,MAAQ,UACb,KAAK,OAAO,MAAA,CAChB,CACA,OAAQ,CACJ,IAAIE,EACJ,GAAI,CAAC,KAAK,UAAW,CACjB,KAAK,iBAAmB,SACxB,MACJ,CACA,KAAK,MAAQ,SACb,KAAK,UAAYA,EAAK,KAAK,eAAiB,MAAQA,IAAO,OAASA,EAAK,CAC7E,CACA,UAAW,CACH,KAAK,QAAU,WACf,KAAK,KAAA,EAET,KAAK,iBAAmB,KAAK,MAAQ,WACrC,KAAK,SAAW,IACpB,CACA,QAAS,CACL,KAAK,SAAA,EACL,KAAK,MAAQ,WACb,KAAM,CAAE,WAAAC,GAAe,KAAK,QAC5BA,GAAcA,EAAA,CAClB,CACA,QAAS,CACD,KAAK,aAAe,MACpB,KAAK,KAAK,KAAK,UAAU,EAE7B,KAAK,SAAA,EACL,KAAK,sBAAA,CACT,CACA,UAAW,CACP,KAAK,MAAQ,OACb,KAAK,WAAA,EACL,KAAK,uBAAA,EACL,KAAK,sBAAA,EACL,KAAK,UAAY,KAAK,WAAa,KACnC,KAAK,SAAS,OAAA,CAClB,CACA,YAAa,CACJ,KAAK,SAEV,KAAK,OAAO,KAAA,EACZ,KAAK,OAAS,OAClB,CACA,OAAOC,EAAM,CACT,YAAK,UAAY,EACV,KAAK,KAAKA,EAAM,EAAI,CAC/B,CACJ","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/generators/inertia.js.map

@@ -1 +1 @@
-{"version":3,"file":"inertia.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/generators/inertia.mjs"],"sourcesContent":["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"],"names":["inertia","keyframes","velocity","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","min","max","restDelta","restSpeed","origin","state","isOutOfBounds","v","nearestBoundary","amplitude","ideal","target","calcDelta","t","calcLatest","applyFriction","delta","latest","timeReachedBoundary","spring$1","checkCatchBoundary","spring","calcGeneratorVelocity","hasUpdatedFrame"],"mappings":"uGAGA,SAASA,EAAQ,CAAE,UAAAC,EAAW,SAAAC,EAAW,EAAK,MAAAC,EAAQ,GAAK,aAAAC,EAAe,IAAK,cAAAC,EAAgB,GAAI,gBAAAC,EAAkB,IAAK,aAAAC,EAAc,IAAAC,EAAK,IAAAC,EAAK,UAAAC,EAAY,GAAK,UAAAC,GAAc,CAC7K,MAAMC,EAASX,EAAU,CAAC,EACpBY,EAAQ,CACV,KAAM,GACN,MAAOD,CACf,EACUE,EAAiBC,GAAOP,IAAQ,QAAaO,EAAIP,GAASC,IAAQ,QAAaM,EAAIN,EACnFO,EAAmBD,GACjBP,IAAQ,OACDC,EACPA,IAAQ,QAEL,KAAK,IAAID,EAAMO,CAAC,EAAI,KAAK,IAAIN,EAAMM,CAAC,EADhCP,EAC0CC,EAEzD,IAAIQ,EAAYd,EAAQD,EACxB,MAAMgB,EAAQN,EAASK,EACjBE,EAASZ,IAAiB,OAAYW,EAAQX,EAAaW,CAAK,EAKlEC,IAAWD,IACXD,EAAYE,EAASP,GACzB,MAAMQ,EAAaC,GAAM,CAACJ,EAAY,KAAK,IAAI,CAACI,EAAIjB,CAAY,EAC1DkB,EAAcD,GAAMF,EAASC,EAAUC,CAAC,EACxCE,EAAiBF,GAAM,CACzB,MAAMG,EAAQJ,EAAUC,CAAC,EACnBI,EAASH,EAAWD,CAAC,EAC3BR,EAAM,KAAO,KAAK,IAAIW,CAAK,GAAKd,EAChCG,EAAM,MAAQA,EAAM,KAAOM,EAASM,CAC5C,EAOI,IAAIC,EACAC,EACJ,MAAMC,EAAsBP,GAAM,CACzBP,EAAcD,EAAM,KAAK,IAE9Ba,EAAsBL,EACtBM,EAAWE,EAAO,CACd,UAAW,CAAChB,EAAM,MAAOG,EAAgBH,EAAM,KAAK,CAAC,EACrD,SAAUiB,EAAsBR,EAAYD,EAAGR,EAAM,KAAK,EAC1D,QAASR,EACT,UAAWC,EACX,UAAAI,EACA,UAAAC,CACZ,CAAS,EACT,EACI,OAAAiB,EAAmB,CAAC,EACb,CACH,mBAAoB,KACpB,KAAOP,GAAM,CAOT,IAAIU,EAAkB,GAUtB,MATI,CAACJ,GAAYD,IAAwB,SACrCK,EAAkB,GAClBR,EAAcF,CAAC,EACfO,EAAmBP,CAAC,GAMpBK,IAAwB,QAAaL,GAAKK,EACnCC,EAAS,KAAKN,EAAIK,CAAmB,GAG5C,CAACK,GAAmBR,EAAcF,CAAC,EAC5BR,EAEvB,CACA,CACA","x_google_ignoreList":[0]}
+{"version":3,"file":"inertia.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/generators/inertia.mjs"],"sourcesContent":["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"],"names":["inertia","keyframes","velocity","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","min","max","restDelta","restSpeed","origin","state","isOutOfBounds","v","nearestBoundary","amplitude","ideal","target","calcDelta","t","calcLatest","applyFriction","delta","latest","timeReachedBoundary","spring$1","checkCatchBoundary","spring","calcGeneratorVelocity","hasUpdatedFrame"],"mappings":"uGAGA,SAASA,EAAQ,CAAE,UAAAC,EAAW,SAAAC,EAAW,EAAK,MAAAC,EAAQ,GAAK,aAAAC,EAAe,IAAK,cAAAC,EAAgB,GAAI,gBAAAC,EAAkB,IAAK,aAAAC,EAAc,IAAAC,EAAK,IAAAC,EAAK,UAAAC,EAAY,GAAK,UAAAC,GAAc,CAC7K,MAAMC,EAASX,EAAU,CAAC,EACpBY,EAAQ,CACV,KAAM,GACN,MAAOD,CACf,EACUE,EAAiBC,GAAOP,IAAQ,QAAaO,EAAIP,GAASC,IAAQ,QAAaM,EAAIN,EACnFO,EAAmBD,GACjBP,IAAQ,OACDC,EACPA,IAAQ,QAEL,KAAK,IAAID,EAAMO,CAAC,EAAI,KAAK,IAAIN,EAAMM,CAAC,EADhCP,EAC0CC,EAEzD,IAAIQ,EAAYd,EAAQD,EACxB,MAAMgB,EAAQN,EAASK,EACjBE,EAASZ,IAAiB,OAAYW,EAAQX,EAAaW,CAAK,EAKlEC,IAAWD,IACXD,EAAYE,EAASP,GACzB,MAAMQ,EAAaC,GAAM,CAACJ,EAAY,KAAK,IAAI,CAACI,EAAIjB,CAAY,EAC1DkB,EAAcD,GAAMF,EAASC,EAAUC,CAAC,EACxCE,EAAiBF,GAAM,CACzB,MAAMG,EAAQJ,EAAUC,CAAC,EACnBI,EAASH,EAAWD,CAAC,EAC3BR,EAAM,KAAO,KAAK,IAAIW,CAAK,GAAKd,EAChCG,EAAM,MAAQA,EAAM,KAAOM,EAASM,CACxC,EAOA,IAAIC,EACAC,EACJ,MAAMC,EAAsBP,GAAM,CACzBP,EAAcD,EAAM,KAAK,IAE9Ba,EAAsBL,EACtBM,EAAWE,EAAO,CACd,UAAW,CAAChB,EAAM,MAAOG,EAAgBH,EAAM,KAAK,CAAC,EACrD,SAAUiB,EAAsBR,EAAYD,EAAGR,EAAM,KAAK,EAC1D,QAASR,EACT,UAAWC,EACX,UAAAI,EACA,UAAAC,CACZ,CAAS,EACL,EACA,OAAAiB,EAAmB,CAAC,EACb,CACH,mBAAoB,KACpB,KAAOP,GAAM,CAOT,IAAIU,EAAkB,GAUtB,MATI,CAACJ,GAAYD,IAAwB,SACrCK,EAAkB,GAClBR,EAAcF,CAAC,EACfO,EAAmBP,CAAC,GAMpBK,IAAwB,QAAaL,GAAKK,EACnCC,EAAS,KAAKN,EAAIK,CAAmB,GAG5C,CAACK,GAAmBR,EAAcF,CAAC,EAC5BR,EAEf,CACR,CACA","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/generators/spring/find.js.map

@@ -1 +1 @@
-{"version":3,"file":"find.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs"],"sourcesContent":["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"],"names":["safeMin","findSpring","duration","springDefaults","bounce","velocity","mass","envelope","derivative","dampingRatio","clamp","millisecondsToSeconds","undampedFreq","exponentialDecay","delta","a","b","calcAngularFreq","c","d","e","f","g","initialGuess","approximateRoot","secondsToMilliseconds","stiffness","rootIterations","result"],"mappings":"4NAIA,MAAMA,EAAU,KAChB,SAASC,EAAW,CAAE,SAAAC,EAAWC,EAAe,SAAU,OAAAC,EAASD,EAAe,OAAQ,SAAAE,EAAWF,EAAe,SAAU,KAAAG,EAAOH,EAAe,IAAI,EAAK,CACzJ,IAAII,EACAC,EAEAC,EAAe,EAAIL,EAIvBK,EAAeC,EAAMP,EAAe,WAAYA,EAAe,WAAYM,CAAY,EACvFP,EAAWQ,EAAMP,EAAe,YAAaA,EAAe,YAAaQ,EAAsBT,CAAQ,CAAC,EACpGO,EAAe,GAIfF,EAAYK,GAAiB,CACzB,MAAMC,EAAmBD,EAAeH,EAClCK,EAAQD,EAAmBX,EAC3Ba,EAAIF,EAAmBR,EACvBW,EAAIC,EAAgBL,EAAcH,CAAY,EAC9CS,EAAI,KAAK,IAAI,CAACJ,CAAK,EACzB,OAAOd,EAAWe,EAAIC,EAAKE,CACvC,EACQV,EAAcI,GAAiB,CAE3B,MAAME,EADmBF,EAAeH,EACPP,EAC3BiB,EAAIL,EAAQT,EAAWA,EACvBe,EAAI,KAAK,IAAIX,EAAc,CAAC,EAAI,KAAK,IAAIG,EAAc,CAAC,EAAIV,EAC5DmB,EAAI,KAAK,IAAI,CAACP,CAAK,EACnBQ,EAAIL,EAAgB,KAAK,IAAIL,EAAc,CAAC,EAAGH,CAAY,EAEjE,OADe,CAACF,EAASK,CAAY,EAAIZ,EAAU,EAAI,GAAK,KACzCmB,EAAIC,GAAKC,GAAMC,CAC9C,IAMQf,EAAYK,GAAiB,CACzB,MAAMG,EAAI,KAAK,IAAI,CAACH,EAAeV,CAAQ,EACrCc,GAAKJ,EAAeP,GAAYH,EAAW,EACjD,MAAO,CAACF,EAAUe,EAAIC,CAClC,EACQR,EAAcI,GAAiB,CAC3B,MAAMG,EAAI,KAAK,IAAI,CAACH,EAAeV,CAAQ,EACrCc,GAAKX,EAAWO,IAAiBV,EAAWA,GAClD,OAAOa,EAAIC,CACvB,GAEI,MAAMO,EAAe,EAAIrB,EACnBU,EAAeY,EAAgBjB,EAAUC,EAAYe,CAAY,EAEvE,GADArB,EAAWuB,EAAsBvB,CAAQ,EACrC,MAAMU,CAAY,EAClB,MAAO,CACH,UAAWT,EAAe,UAC1B,QAASA,EAAe,QACxB,SAAAD,CACZ,EAES,CACD,MAAMwB,EAAY,KAAK,IAAId,EAAc,CAAC,EAAIN,EAC9C,MAAO,CACH,UAAAoB,EACA,QAASjB,EAAe,EAAI,KAAK,KAAKH,EAAOoB,CAAS,EACtD,SAAAxB,CACZ,CACA,CACA,CACA,MAAMyB,EAAiB,GACvB,SAASH,EAAgBjB,EAAUC,EAAYe,EAAc,CACzD,IAAIK,EAASL,EACb,QAAS,EAAI,EAAG,EAAII,EAAgB,IAChCC,EAASA,EAASrB,EAASqB,CAAM,EAAIpB,EAAWoB,CAAM,EAE1D,OAAOA,CACX,CACA,SAASX,EAAgBL,EAAcH,EAAc,CACjD,OAAOG,EAAe,KAAK,KAAK,EAAIH,EAAeA,CAAY,CACnE","x_google_ignoreList":[0]}
+{"version":3,"file":"find.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs"],"sourcesContent":["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"],"names":["safeMin","findSpring","duration","springDefaults","bounce","velocity","mass","envelope","derivative","dampingRatio","clamp","millisecondsToSeconds","undampedFreq","exponentialDecay","delta","a","b","calcAngularFreq","c","d","e","f","g","initialGuess","approximateRoot","secondsToMilliseconds","stiffness","rootIterations","result"],"mappings":"4NAIA,MAAMA,EAAU,KAChB,SAASC,EAAW,CAAE,SAAAC,EAAWC,EAAe,SAAU,OAAAC,EAASD,EAAe,OAAQ,SAAAE,EAAWF,EAAe,SAAU,KAAAG,EAAOH,EAAe,IAAI,EAAK,CACzJ,IAAII,EACAC,EAEAC,EAAe,EAAIL,EAIvBK,EAAeC,EAAMP,EAAe,WAAYA,EAAe,WAAYM,CAAY,EACvFP,EAAWQ,EAAMP,EAAe,YAAaA,EAAe,YAAaQ,EAAsBT,CAAQ,CAAC,EACpGO,EAAe,GAIfF,EAAYK,GAAiB,CACzB,MAAMC,EAAmBD,EAAeH,EAClCK,EAAQD,EAAmBX,EAC3Ba,EAAIF,EAAmBR,EACvBW,EAAIC,EAAgBL,EAAcH,CAAY,EAC9CS,EAAI,KAAK,IAAI,CAACJ,CAAK,EACzB,OAAOd,EAAWe,EAAIC,EAAKE,CAC/B,EACAV,EAAcI,GAAiB,CAE3B,MAAME,EADmBF,EAAeH,EACPP,EAC3BiB,EAAIL,EAAQT,EAAWA,EACvBe,EAAI,KAAK,IAAIX,EAAc,CAAC,EAAI,KAAK,IAAIG,EAAc,CAAC,EAAIV,EAC5DmB,EAAI,KAAK,IAAI,CAACP,CAAK,EACnBQ,EAAIL,EAAgB,KAAK,IAAIL,EAAc,CAAC,EAAGH,CAAY,EAEjE,OADe,CAACF,EAASK,CAAY,EAAIZ,EAAU,EAAI,GAAK,KACzCmB,EAAIC,GAAKC,GAAMC,CACtC,IAMAf,EAAYK,GAAiB,CACzB,MAAMG,EAAI,KAAK,IAAI,CAACH,EAAeV,CAAQ,EACrCc,GAAKJ,EAAeP,GAAYH,EAAW,EACjD,MAAO,CAACF,EAAUe,EAAIC,CAC1B,EACAR,EAAcI,GAAiB,CAC3B,MAAMG,EAAI,KAAK,IAAI,CAACH,EAAeV,CAAQ,EACrCc,GAAKX,EAAWO,IAAiBV,EAAWA,GAClD,OAAOa,EAAIC,CACf,GAEJ,MAAMO,EAAe,EAAIrB,EACnBU,EAAeY,EAAgBjB,EAAUC,EAAYe,CAAY,EAEvE,GADArB,EAAWuB,EAAsBvB,CAAQ,EACrC,MAAMU,CAAY,EAClB,MAAO,CACH,UAAWT,EAAe,UAC1B,QAASA,EAAe,QACxB,SAAAD,CACZ,EAES,CACD,MAAMwB,EAAY,KAAK,IAAId,EAAc,CAAC,EAAIN,EAC9C,MAAO,CACH,UAAAoB,EACA,QAASjB,EAAe,EAAI,KAAK,KAAKH,EAAOoB,CAAS,EACtD,SAAAxB,CACZ,CACI,CACJ,CACA,MAAMyB,EAAiB,GACvB,SAASH,EAAgBjB,EAAUC,EAAYe,EAAc,CACzD,IAAIK,EAASL,EACb,QAAS,EAAI,EAAG,EAAII,EAAgB,IAChCC,EAASA,EAASrB,EAASqB,CAAM,EAAIpB,EAAWoB,CAAM,EAE1D,OAAOA,CACX,CACA,SAASX,EAAgBL,EAAcH,EAAc,CACjD,OAAOG,EAAe,KAAK,KAAK,EAAIH,EAAeA,CAAY,CACnE","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/generators/spring/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["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"],"names":["durationKeys","physicsKeys","isSpringType","options","keys","key","getSpringOptions","springOptions","springDefaults","visualDuration","root","stiffness","damping","clamp","derived","findSpring","spring","optionsOrVisualDuration","bounce","restSpeed","restDelta","origin","target","state","mass","duration","velocity","isResolvedFromDuration","millisecondsToSeconds","initialVelocity","dampingRatio","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","calcAngularFreq","t","envelope","dampedAngularFreq","freqForT","generator","current","currentVelocity","secondsToMilliseconds","calcGeneratorVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","calculatedDuration","calcGeneratorDuration","maxGeneratorDuration","easing","generateLinearEasing","progress"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["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"],"names":["durationKeys","physicsKeys","isSpringType","options","keys","key","getSpringOptions","springOptions","springDefaults","visualDuration","root","stiffness","damping","clamp","derived","findSpring","spring","optionsOrVisualDuration","bounce","restSpeed","restDelta","origin","target","state","mass","duration","velocity","isResolvedFromDuration","millisecondsToSeconds","initialVelocity","dampingRatio","initialDelta","undampedAngularFreq","isGranularScale","resolveSpring","angularFreq","calcAngularFreq","t","envelope","dampedAngularFreq","freqForT","generator","current","currentVelocity","secondsToMilliseconds","calcGeneratorVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","calculatedDuration","calcGeneratorDuration","maxGeneratorDuration","easing","generateLinearEasing","progress"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/motion-value.js.map

@@ -1 +1 @@
-{"version":3,"file":"motion-value.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["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"],"names":["animateMotionValue","name","value","target","transition","element","isHandoff","onComplete","valueTransition","getValueTransition","delay","elapsed","secondsToMilliseconds","options","v","isTransitionDefined","getDefaultTransition","shouldSkip","finalKeyframe","getFinalKeyframe","frame","GroupPlaybackControls","AcceleratedAnimation","MainThreadAnimation"],"mappings":"4tBAWK,MAACA,EAAqB,CAACC,EAAMC,EAAOC,EAAQC,EAAa,CAAA,EAAIC,EAASC,IAAeC,GAAe,CACrG,MAAMC,EAAkBC,EAAmBL,EAAYH,CAAI,GAAK,CAAA,EAM1DS,EAAQF,EAAgB,OAASJ,EAAW,OAAS,EAK3D,GAAI,CAAE,QAAAO,EAAU,CAAC,EAAKP,EACtBO,EAAUA,EAAUC,EAAsBF,CAAK,EAC/C,IAAIG,EAAU,CACV,UAAW,MAAM,QAAQV,CAAM,EAAIA,EAAS,CAAC,KAAMA,CAAM,EACzD,KAAM,UACN,SAAUD,EAAM,YAAW,EAC3B,GAAGM,EACH,MAAO,CAACG,EACR,SAAWG,GAAM,CACbZ,EAAM,IAAIY,CAAC,EACXN,EAAgB,UAAYA,EAAgB,SAASM,CAAC,CAClE,EACQ,WAAY,IAAM,CACdP,EAAU,EACVC,EAAgB,YAAcA,EAAgB,WAAU,CACpE,EACQ,KAAAP,EACA,YAAaC,EACb,QAASI,EAAY,OAAYD,CACzC,EAKSU,EAAoBP,CAAe,IACpCK,EAAU,CACN,GAAGA,EACH,GAAGG,EAAqBf,EAAMY,CAAO,CACjD,GAOQA,EAAQ,WACRA,EAAQ,SAAWD,EAAsBC,EAAQ,QAAQ,GAEzDA,EAAQ,cACRA,EAAQ,YAAcD,EAAsBC,EAAQ,WAAW,GAE/DA,EAAQ,OAAS,SACjBA,EAAQ,UAAU,CAAC,EAAIA,EAAQ,MAEnC,IAAII,EAAa,GAmBjB,IAlBIJ,EAAQ,OAAS,IAChBA,EAAQ,WAAa,GAAK,CAACA,EAAQ,eACpCA,EAAQ,SAAW,EACfA,EAAQ,QAAU,IAClBI,EAAa,KAcjBA,GAAc,CAACX,GAAaJ,EAAM,IAAG,IAAO,OAAW,CACvD,MAAMgB,EAAgBC,EAAiBN,EAAQ,UAAWL,CAAe,EACzE,GAAIU,IAAkB,OAClB,OAAAE,EAAM,OAAO,IAAM,CACfP,EAAQ,SAASK,CAAa,EAC9BL,EAAQ,WAAU,CAClC,CAAa,EAGM,IAAIQ,EAAsB,EAAE,CAE/C,CAMI,MAAI,CAACf,GAAagB,EAAqB,SAAST,CAAO,EAC5C,IAAIS,EAAqBT,CAAO,EAGhC,IAAIU,EAAoBV,CAAO,CAE9C","x_google_ignoreList":[0]}
+{"version":3,"file":"motion-value.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["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"],"names":["animateMotionValue","name","value","target","transition","element","isHandoff","onComplete","valueTransition","getValueTransition","delay","elapsed","secondsToMilliseconds","options","v","isTransitionDefined","getDefaultTransition","shouldSkip","finalKeyframe","getFinalKeyframe","frame","GroupPlaybackControls","AcceleratedAnimation","MainThreadAnimation"],"mappings":"4tBAWK,MAACA,EAAqB,CAACC,EAAMC,EAAOC,EAAQC,EAAa,CAAA,EAAIC,EAASC,IAAeC,GAAe,CACrG,MAAMC,EAAkBC,EAAmBL,EAAYH,CAAI,GAAK,CAAA,EAM1DS,EAAQF,EAAgB,OAASJ,EAAW,OAAS,EAK3D,GAAI,CAAE,QAAAO,EAAU,CAAC,EAAKP,EACtBO,EAAUA,EAAUC,EAAsBF,CAAK,EAC/C,IAAIG,EAAU,CACV,UAAW,MAAM,QAAQV,CAAM,EAAIA,EAAS,CAAC,KAAMA,CAAM,EACzD,KAAM,UACN,SAAUD,EAAM,YAAW,EAC3B,GAAGM,EACH,MAAO,CAACG,EACR,SAAWG,GAAM,CACbZ,EAAM,IAAIY,CAAC,EACXN,EAAgB,UAAYA,EAAgB,SAASM,CAAC,CAC1D,EACA,WAAY,IAAM,CACdP,EAAU,EACVC,EAAgB,YAAcA,EAAgB,WAAU,CAC5D,EACA,KAAAP,EACA,YAAaC,EACb,QAASI,EAAY,OAAYD,CACzC,EAKSU,EAAoBP,CAAe,IACpCK,EAAU,CACN,GAAGA,EACH,GAAGG,EAAqBf,EAAMY,CAAO,CACjD,GAOQA,EAAQ,WACRA,EAAQ,SAAWD,EAAsBC,EAAQ,QAAQ,GAEzDA,EAAQ,cACRA,EAAQ,YAAcD,EAAsBC,EAAQ,WAAW,GAE/DA,EAAQ,OAAS,SACjBA,EAAQ,UAAU,CAAC,EAAIA,EAAQ,MAEnC,IAAII,EAAa,GAmBjB,IAlBIJ,EAAQ,OAAS,IAChBA,EAAQ,WAAa,GAAK,CAACA,EAAQ,eACpCA,EAAQ,SAAW,EACfA,EAAQ,QAAU,IAClBI,EAAa,KAcjBA,GAAc,CAACX,GAAaJ,EAAM,IAAG,IAAO,OAAW,CACvD,MAAMgB,EAAgBC,EAAiBN,EAAQ,UAAWL,CAAe,EACzE,GAAIU,IAAkB,OAClB,OAAAE,EAAM,OAAO,IAAM,CACfP,EAAQ,SAASK,CAAa,EAC9BL,EAAQ,WAAU,CACtB,CAAC,EAGM,IAAIQ,EAAsB,EAAE,CAE3C,CAMA,MAAI,CAACf,GAAagB,EAAqB,SAAST,CAAO,EAC5C,IAAIS,EAAqBT,CAAO,EAGhC,IAAIU,EAAoBV,CAAO,CAE9C","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.js.map

@@ -1 +1 @@
-{"version":3,"file":"visual-element-target.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs"],"sourcesContent":["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"],"names":["shouldBlockAnimation","protectedKeys","needsAnimating","key","shouldBlock","animateTarget","visualElement","targetAndTransition","delay","transitionOverride","type","_a","transition","transitionEnd","target","animations","animationTypeState","value","valueTarget","valueTransition","getValueTransition","isHandoff","appearId","getOptimisedAppearId","startTime","frame","addValueToWillChange","animateMotionValue","positionalKeys","animation","setTarget"],"mappings":"6fAcA,SAASA,EAAqB,CAAE,cAAAC,EAAe,eAAAC,CAAc,EAAIC,EAAK,CAClE,MAAMC,EAAcH,EAAc,eAAeE,CAAG,GAAKD,EAAeC,CAAG,IAAM,GACjF,OAAAD,EAAeC,CAAG,EAAI,GACfC,CACX,CACA,SAASC,EAAcC,EAAeC,EAAqB,CAAE,MAAAC,EAAQ,EAAG,mBAAAC,EAAoB,KAAAC,CAAI,EAAK,GAAI,CACrG,IAAIC,EACJ,GAAI,CAAE,WAAAC,EAAaN,EAAc,qBAAoB,EAAI,cAAAO,EAAe,GAAGC,CAAM,EAAKP,EAClFE,IACAG,EAAaH,GACjB,MAAMM,EAAa,CAAA,EACbC,EAAqBN,GACvBJ,EAAc,gBACdA,EAAc,eAAe,SAAQ,EAAGI,CAAI,EAChD,UAAWP,KAAOW,EAAQ,CACtB,MAAMG,EAAQX,EAAc,SAASH,GAAMQ,EAAKL,EAAc,aAAaH,CAAG,KAAO,MAAQQ,IAAO,OAASA,EAAK,IAAI,EAChHO,EAAcJ,EAAOX,CAAG,EAC9B,GAAIe,IAAgB,QACfF,GACGhB,EAAqBgB,EAAoBb,CAAG,EAChD,SAEJ,MAAMgB,EAAkB,CACpB,MAAAX,EACA,GAAGY,EAAmBR,GAAc,CAAA,EAAIT,CAAG,CACvD,EAKQ,IAAIkB,EAAY,GAChB,GAAI,OAAO,uBAAwB,CAC/B,MAAMC,EAAWC,EAAqBjB,CAAa,EACnD,GAAIgB,EAAU,CACV,MAAME,EAAY,OAAO,uBAAuBF,EAAUnB,EAAKsB,CAAK,EAChED,IAAc,OACdL,EAAgB,UAAYK,EAC5BH,EAAY,GAEhC,CACA,CACQK,EAAqBpB,EAAeH,CAAG,EACvCc,EAAM,MAAMU,EAAmBxB,EAAKc,EAAOC,EAAaZ,EAAc,oBAAsBsB,EAAe,IAAIzB,CAAG,EAC5G,CAAE,KAAM,EAAK,EACbgB,EAAiBb,EAAee,CAAS,CAAC,EAChD,MAAMQ,EAAYZ,EAAM,UACpBY,GACAd,EAAW,KAAKc,CAAS,CAErC,CACI,OAAIhB,GACA,QAAQ,IAAIE,CAAU,EAAE,KAAK,IAAM,CAC/BU,EAAM,OAAO,IAAM,CACfZ,GAAiBiB,EAAUxB,EAAeO,CAAa,CACvE,CAAa,CACb,CAAS,EAEEE,CACX","x_google_ignoreList":[0]}
+{"version":3,"file":"visual-element-target.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs"],"sourcesContent":["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"],"names":["shouldBlockAnimation","protectedKeys","needsAnimating","key","shouldBlock","animateTarget","visualElement","targetAndTransition","delay","transitionOverride","type","_a","transition","transitionEnd","target","animations","animationTypeState","value","valueTarget","valueTransition","getValueTransition","isHandoff","appearId","getOptimisedAppearId","startTime","frame","addValueToWillChange","animateMotionValue","positionalKeys","animation","setTarget"],"mappings":"6fAcA,SAASA,EAAqB,CAAE,cAAAC,EAAe,eAAAC,CAAc,EAAIC,EAAK,CAClE,MAAMC,EAAcH,EAAc,eAAeE,CAAG,GAAKD,EAAeC,CAAG,IAAM,GACjF,OAAAD,EAAeC,CAAG,EAAI,GACfC,CACX,CACA,SAASC,EAAcC,EAAeC,EAAqB,CAAE,MAAAC,EAAQ,EAAG,mBAAAC,EAAoB,KAAAC,CAAI,EAAK,GAAI,CACrG,IAAIC,EACJ,GAAI,CAAE,WAAAC,EAAaN,EAAc,qBAAoB,EAAI,cAAAO,EAAe,GAAGC,CAAM,EAAKP,EAClFE,IACAG,EAAaH,GACjB,MAAMM,EAAa,CAAA,EACbC,EAAqBN,GACvBJ,EAAc,gBACdA,EAAc,eAAe,SAAQ,EAAGI,CAAI,EAChD,UAAWP,KAAOW,EAAQ,CACtB,MAAMG,EAAQX,EAAc,SAASH,GAAMQ,EAAKL,EAAc,aAAaH,CAAG,KAAO,MAAQQ,IAAO,OAASA,EAAK,IAAI,EAChHO,EAAcJ,EAAOX,CAAG,EAC9B,GAAIe,IAAgB,QACfF,GACGhB,EAAqBgB,EAAoBb,CAAG,EAChD,SAEJ,MAAMgB,EAAkB,CACpB,MAAAX,EACA,GAAGY,EAAmBR,GAAc,CAAA,EAAIT,CAAG,CACvD,EAKQ,IAAIkB,EAAY,GAChB,GAAI,OAAO,uBAAwB,CAC/B,MAAMC,EAAWC,EAAqBjB,CAAa,EACnD,GAAIgB,EAAU,CACV,MAAME,EAAY,OAAO,uBAAuBF,EAAUnB,EAAKsB,CAAK,EAChED,IAAc,OACdL,EAAgB,UAAYK,EAC5BH,EAAY,GAEpB,CACJ,CACAK,EAAqBpB,EAAeH,CAAG,EACvCc,EAAM,MAAMU,EAAmBxB,EAAKc,EAAOC,EAAaZ,EAAc,oBAAsBsB,EAAe,IAAIzB,CAAG,EAC5G,CAAE,KAAM,EAAK,EACbgB,EAAiBb,EAAee,CAAS,CAAC,EAChD,MAAMQ,EAAYZ,EAAM,UACpBY,GACAd,EAAW,KAAKc,CAAS,CAEjC,CACA,OAAIhB,GACA,QAAQ,IAAIE,CAAU,EAAE,KAAK,IAAM,CAC/BU,EAAM,OAAO,IAAM,CACfZ,GAAiBiB,EAAUxB,EAAeO,CAAa,CAC3D,CAAC,CACL,CAAC,EAEEE,CACX","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.js.map

@@ -1 +1 @@
-{"version":3,"file":"visual-element-variant.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs"],"sourcesContent":["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"],"names":["animateVariant","visualElement","variant","options","_a","resolved","resolveVariant","transition","getAnimation","animateTarget","getChildAnimations","forwardDelay","delayChildren","staggerChildren","staggerDirection","animateChildren","when","first","last","animations","maxStaggerDuration","generateStaggerDuration","i","sortByTreeOrder","child","a","b"],"mappings":"2IAGA,SAASA,EAAeC,EAAeC,EAASC,EAAU,CAAA,EAAI,CAC1D,IAAIC,EACJ,MAAMC,EAAWC,EAAeL,EAAeC,EAASC,EAAQ,OAAS,QAClEC,EAAKH,EAAc,mBAAqB,MAAQG,IAAO,OAAS,OAASA,EAAG,OAC7E,MAAS,EACf,GAAI,CAAE,WAAAG,EAAaN,EAAc,qBAAoB,GAAM,CAAA,CAAE,EAAKI,GAAY,CAAA,EAC1EF,EAAQ,qBACRI,EAAaJ,EAAQ,oBAMzB,MAAMK,EAAeH,EACf,IAAM,QAAQ,IAAII,EAAcR,EAAeI,EAAUF,CAAO,CAAC,EACjE,IAAM,QAAQ,QAAO,EAKrBO,EAAqBT,EAAc,iBAAmBA,EAAc,gBAAgB,KACpF,CAACU,EAAe,IAAM,CACpB,KAAM,CAAE,cAAAC,EAAgB,EAAG,gBAAAC,EAAiB,iBAAAC,CAAgB,EAAMP,EAClE,OAAOQ,EAAgBd,EAAeC,EAASU,EAAgBD,EAAcE,EAAiBC,EAAkBX,CAAO,CACnI,EACU,IAAM,QAAQ,QAAO,EAKrB,CAAE,KAAAa,CAAI,EAAKT,EACjB,GAAIS,EAAM,CACN,KAAM,CAACC,EAAOC,CAAI,EAAIF,IAAS,iBACzB,CAACR,EAAcE,CAAkB,EACjC,CAACA,EAAoBF,CAAY,EACvC,OAAOS,EAAK,EAAG,KAAK,IAAMC,EAAI,CAAE,CACxC,KAEQ,QAAO,QAAQ,IAAI,CAACV,EAAY,EAAIE,EAAmBP,EAAQ,KAAK,CAAC,CAAC,CAE9E,CACA,SAASY,EAAgBd,EAAeC,EAASU,EAAgB,EAAGC,EAAkB,EAAGC,EAAmB,EAAGX,EAAS,CACpH,MAAMgB,EAAa,CAAA,EACbC,GAAsBnB,EAAc,gBAAgB,KAAO,GAAKY,EAChEQ,EAA0BP,IAAqB,EAC/C,CAACQ,EAAI,IAAMA,EAAIT,EACf,CAACS,EAAI,IAAMF,EAAqBE,EAAIT,EAC1C,aAAM,KAAKZ,EAAc,eAAe,EACnC,KAAKsB,CAAe,EACpB,QAAQ,CAACC,EAAOF,IAAM,CACvBE,EAAM,OAAO,iBAAkBtB,CAAO,EACtCiB,EAAW,KAAKnB,EAAewB,EAAOtB,EAAS,CAC3C,GAAGC,EACH,MAAOS,EAAgBS,EAAwBC,CAAC,CAC5D,CAAS,EAAE,KAAK,IAAME,EAAM,OAAO,oBAAqBtB,CAAO,CAAC,CAAC,CACjE,CAAK,EACM,QAAQ,IAAIiB,CAAU,CACjC,CACA,SAASI,EAAgBE,EAAGC,EAAG,CAC3B,OAAOD,EAAE,iBAAiBC,CAAC,CAC/B","x_google_ignoreList":[0]}
+{"version":3,"file":"visual-element-variant.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs"],"sourcesContent":["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"],"names":["animateVariant","visualElement","variant","options","_a","resolved","resolveVariant","transition","getAnimation","animateTarget","getChildAnimations","forwardDelay","delayChildren","staggerChildren","staggerDirection","animateChildren","when","first","last","animations","maxStaggerDuration","generateStaggerDuration","i","sortByTreeOrder","child","a","b"],"mappings":"2IAGA,SAASA,EAAeC,EAAeC,EAASC,EAAU,CAAA,EAAI,CAC1D,IAAIC,EACJ,MAAMC,EAAWC,EAAeL,EAAeC,EAASC,EAAQ,OAAS,QAClEC,EAAKH,EAAc,mBAAqB,MAAQG,IAAO,OAAS,OAASA,EAAG,OAC7E,MAAS,EACf,GAAI,CAAE,WAAAG,EAAaN,EAAc,qBAAoB,GAAM,CAAA,CAAE,EAAKI,GAAY,CAAA,EAC1EF,EAAQ,qBACRI,EAAaJ,EAAQ,oBAMzB,MAAMK,EAAeH,EACf,IAAM,QAAQ,IAAII,EAAcR,EAAeI,EAAUF,CAAO,CAAC,EACjE,IAAM,QAAQ,QAAO,EAKrBO,EAAqBT,EAAc,iBAAmBA,EAAc,gBAAgB,KACpF,CAACU,EAAe,IAAM,CACpB,KAAM,CAAE,cAAAC,EAAgB,EAAG,gBAAAC,EAAiB,iBAAAC,CAAgB,EAAMP,EAClE,OAAOQ,EAAgBd,EAAeC,EAASU,EAAgBD,EAAcE,EAAiBC,EAAkBX,CAAO,CAC3H,EACE,IAAM,QAAQ,QAAO,EAKrB,CAAE,KAAAa,CAAI,EAAKT,EACjB,GAAIS,EAAM,CACN,KAAM,CAACC,EAAOC,CAAI,EAAIF,IAAS,iBACzB,CAACR,EAAcE,CAAkB,EACjC,CAACA,EAAoBF,CAAY,EACvC,OAAOS,EAAK,EAAG,KAAK,IAAMC,EAAI,CAAE,CACpC,KAEI,QAAO,QAAQ,IAAI,CAACV,EAAY,EAAIE,EAAmBP,EAAQ,KAAK,CAAC,CAAC,CAE9E,CACA,SAASY,EAAgBd,EAAeC,EAASU,EAAgB,EAAGC,EAAkB,EAAGC,EAAmB,EAAGX,EAAS,CACpH,MAAMgB,EAAa,CAAA,EACbC,GAAsBnB,EAAc,gBAAgB,KAAO,GAAKY,EAChEQ,EAA0BP,IAAqB,EAC/C,CAACQ,EAAI,IAAMA,EAAIT,EACf,CAACS,EAAI,IAAMF,EAAqBE,EAAIT,EAC1C,aAAM,KAAKZ,EAAc,eAAe,EACnC,KAAKsB,CAAe,EACpB,QAAQ,CAACC,EAAOF,IAAM,CACvBE,EAAM,OAAO,iBAAkBtB,CAAO,EACtCiB,EAAW,KAAKnB,EAAewB,EAAOtB,EAAS,CAC3C,GAAGC,EACH,MAAOS,EAAgBS,EAAwBC,CAAC,CAC5D,CAAS,EAAE,KAAK,IAAME,EAAM,OAAO,oBAAqBtB,CAAO,CAAC,CAAC,CAC7D,CAAC,EACM,QAAQ,IAAIiB,CAAU,CACjC,CACA,SAASI,EAAgBE,EAAGC,EAAG,CAC3B,OAAOD,EAAE,iBAAiBC,CAAC,CAC/B","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element.js.map

@@ -1 +1 @@
-{"version":3,"file":"visual-element.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs"],"sourcesContent":["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"],"names":["animateVisualElement","visualElement","definition","options","animation","animations","variant","animateVariant","resolvedDefinition","resolveVariant","animateTarget"],"mappings":"wMAIA,SAASA,EAAqBC,EAAeC,EAAYC,EAAU,CAAA,EAAI,CACnEF,EAAc,OAAO,iBAAkBC,CAAU,EACjD,IAAIE,EACJ,GAAI,MAAM,QAAQF,CAAU,EAAG,CAC3B,MAAMG,EAAaH,EAAW,IAAKI,GAAYC,EAAeN,EAAeK,EAASH,CAAO,CAAC,EAC9FC,EAAY,QAAQ,IAAIC,CAAU,CAC1C,SACa,OAAOH,GAAe,SAC3BE,EAAYG,EAAeN,EAAeC,EAAYC,CAAO,MAE5D,CACD,MAAMK,EAAqB,OAAON,GAAe,WAC3CO,EAAeR,EAAeC,EAAYC,EAAQ,MAAM,EACxDD,EACNE,EAAY,QAAQ,IAAIM,EAAcT,EAAeO,EAAoBL,CAAO,CAAC,CACzF,CACI,OAAOC,EAAU,KAAK,IAAM,CACxBH,EAAc,OAAO,oBAAqBC,CAAU,CAC5D,CAAK,CACL","x_google_ignoreList":[0]}
+{"version":3,"file":"visual-element.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs"],"sourcesContent":["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"],"names":["animateVisualElement","visualElement","definition","options","animation","animations","variant","animateVariant","resolvedDefinition","resolveVariant","animateTarget"],"mappings":"wMAIA,SAASA,EAAqBC,EAAeC,EAAYC,EAAU,CAAA,EAAI,CACnEF,EAAc,OAAO,iBAAkBC,CAAU,EACjD,IAAIE,EACJ,GAAI,MAAM,QAAQF,CAAU,EAAG,CAC3B,MAAMG,EAAaH,EAAW,IAAKI,GAAYC,EAAeN,EAAeK,EAASH,CAAO,CAAC,EAC9FC,EAAY,QAAQ,IAAIC,CAAU,CACtC,SACS,OAAOH,GAAe,SAC3BE,EAAYG,EAAeN,EAAeC,EAAYC,CAAO,MAE5D,CACD,MAAMK,EAAqB,OAAON,GAAe,WAC3CO,EAAeR,EAAeC,EAAYC,EAAQ,MAAM,EACxDD,EACNE,EAAY,QAAQ,IAAIM,EAAcT,EAAeO,EAAoBL,CAAO,CAAC,CACrF,CACA,OAAOC,EAAU,KAAK,IAAM,CACxBH,EAAc,OAAO,oBAAqBC,CAAU,CACxD,CAAC,CACL","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.js.map

@@ -1 +1 @@
-{"version":3,"file":"PopChild.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs"],"sourcesContent":["\"use client\";\nimport { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useRef, useContext, useInsertionEffect } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\n\n/**\n * Measurement functionality has to be within a separate component\n * to leverage snapshot lifecycle.\n */\nclass PopChildMeasure extends React.Component {\n    getSnapshotBeforeUpdate(prevProps) {\n        const element = this.props.childRef.current;\n        if (element && prevProps.isPresent && !this.props.isPresent) {\n            const size = this.props.sizeRef.current;\n            size.height = element.offsetHeight || 0;\n            size.width = element.offsetWidth || 0;\n            size.top = element.offsetTop;\n            size.left = element.offsetLeft;\n        }\n        return null;\n    }\n    /**\n     * Required with getSnapshotBeforeUpdate to stop React complaining.\n     */\n    componentDidUpdate() { }\n    render() {\n        return this.props.children;\n    }\n}\nfunction PopChild({ children, isPresent }) {\n    const id = useId();\n    const ref = useRef(null);\n    const size = useRef({\n        width: 0,\n        height: 0,\n        top: 0,\n        left: 0,\n    });\n    const { nonce } = useContext(MotionConfigContext);\n    /**\n     * We create and inject a style block so we can apply this explicit\n     * sizing in a non-destructive manner by just deleting the style block.\n     *\n     * We can't apply size via render as the measurement happens\n     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the\n     * styles directly on the DOM node, we might be overwriting\n     * styles set via the style prop.\n     */\n    useInsertionEffect(() => {\n        const { width, height, top, left } = size.current;\n        if (isPresent || !ref.current || !width || !height)\n            return;\n        ref.current.dataset.motionPopId = id;\n        const style = document.createElement(\"style\");\n        if (nonce)\n            style.nonce = nonce;\n        document.head.appendChild(style);\n        if (style.sheet) {\n            style.sheet.insertRule(`\n          [data-motion-pop-id=\"${id}\"] {\n            position: absolute !important;\n            width: ${width}px !important;\n            height: ${height}px !important;\n            top: ${top}px !important;\n            left: ${left}px !important;\n          }\n        `);\n        }\n        return () => {\n            document.head.removeChild(style);\n        };\n    }, [isPresent]);\n    return (jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref }) }));\n}\n\nexport { PopChild };\n"],"names":["PopChildMeasure","React","prevProps","element","size","PopChild","children","isPresent","id","useId","ref","useRef","nonce","useContext","MotionConfigContext","useInsertionEffect","width","height","top","left","style","jsx"],"mappings":"6NAUA,MAAMA,UAAwBC,EAAM,SAAU,CAC1C,wBAAwBC,EAAW,CAC/B,MAAMC,EAAU,KAAK,MAAM,SAAS,QACpC,GAAIA,GAAWD,EAAU,WAAa,CAAC,KAAK,MAAM,UAAW,CACzD,MAAME,EAAO,KAAK,MAAM,QAAQ,QAChCA,EAAK,OAASD,EAAQ,cAAgB,EACtCC,EAAK,MAAQD,EAAQ,aAAe,EACpCC,EAAK,IAAMD,EAAQ,UACnBC,EAAK,KAAOD,EAAQ,UAChC,CACQ,OAAO,IACf,CAII,oBAAqB,CAAA,CACrB,QAAS,CACL,OAAO,KAAK,MAAM,QAC1B,CACA,CACA,SAASE,EAAS,CAAE,SAAAC,EAAU,UAAAC,GAAa,CACvC,MAAMC,EAAKC,EAAK,EACVC,EAAMC,EAAO,IAAI,EACjBP,EAAOO,EAAO,CAChB,MAAO,EACP,OAAQ,EACR,IAAK,EACL,KAAM,CACd,CAAK,EACK,CAAE,MAAAC,CAAK,EAAKC,EAAWC,CAAmB,EAUhD,OAAAC,EAAmB,IAAM,CACrB,KAAM,CAAE,MAAAC,EAAO,OAAAC,EAAQ,IAAAC,EAAK,KAAAC,CAAI,EAAKf,EAAK,QAC1C,GAAIG,GAAa,CAACG,EAAI,SAAW,CAACM,GAAS,CAACC,EACxC,OACJP,EAAI,QAAQ,QAAQ,YAAcF,EAClC,MAAMY,EAAQ,SAAS,cAAc,OAAO,EAC5C,OAAIR,IACAQ,EAAM,MAAQR,GAClB,SAAS,KAAK,YAAYQ,CAAK,EAC3BA,EAAM,OACNA,EAAM,MAAM,WAAW;AAAA,iCACFZ,CAAE;AAAA;AAAA,qBAEdQ,CAAK;AAAA,sBACJC,CAAM;AAAA,mBACTC,CAAG;AAAA,oBACFC,CAAI;AAAA;AAAA,SAEf,EAEM,IAAM,CACT,SAAS,KAAK,YAAYC,CAAK,CAC3C,CACA,EAAO,CAACb,CAAS,CAAC,EACNc,EAAIrB,EAAiB,CAAE,UAAWO,EAAW,SAAUG,EAAK,QAASN,EAAM,SAAUH,EAAM,aAAaK,EAAU,CAAE,IAAAI,CAAG,CAAE,EAAG,CACxI","x_google_ignoreList":[0]}
+{"version":3,"file":"PopChild.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs"],"sourcesContent":["\"use client\";\nimport { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useRef, useContext, useInsertionEffect } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\n\n/**\n * Measurement functionality has to be within a separate component\n * to leverage snapshot lifecycle.\n */\nclass PopChildMeasure extends React.Component {\n    getSnapshotBeforeUpdate(prevProps) {\n        const element = this.props.childRef.current;\n        if (element && prevProps.isPresent && !this.props.isPresent) {\n            const size = this.props.sizeRef.current;\n            size.height = element.offsetHeight || 0;\n            size.width = element.offsetWidth || 0;\n            size.top = element.offsetTop;\n            size.left = element.offsetLeft;\n        }\n        return null;\n    }\n    /**\n     * Required with getSnapshotBeforeUpdate to stop React complaining.\n     */\n    componentDidUpdate() { }\n    render() {\n        return this.props.children;\n    }\n}\nfunction PopChild({ children, isPresent }) {\n    const id = useId();\n    const ref = useRef(null);\n    const size = useRef({\n        width: 0,\n        height: 0,\n        top: 0,\n        left: 0,\n    });\n    const { nonce } = useContext(MotionConfigContext);\n    /**\n     * We create and inject a style block so we can apply this explicit\n     * sizing in a non-destructive manner by just deleting the style block.\n     *\n     * We can't apply size via render as the measurement happens\n     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the\n     * styles directly on the DOM node, we might be overwriting\n     * styles set via the style prop.\n     */\n    useInsertionEffect(() => {\n        const { width, height, top, left } = size.current;\n        if (isPresent || !ref.current || !width || !height)\n            return;\n        ref.current.dataset.motionPopId = id;\n        const style = document.createElement(\"style\");\n        if (nonce)\n            style.nonce = nonce;\n        document.head.appendChild(style);\n        if (style.sheet) {\n            style.sheet.insertRule(`\n          [data-motion-pop-id=\"${id}\"] {\n            position: absolute !important;\n            width: ${width}px !important;\n            height: ${height}px !important;\n            top: ${top}px !important;\n            left: ${left}px !important;\n          }\n        `);\n        }\n        return () => {\n            document.head.removeChild(style);\n        };\n    }, [isPresent]);\n    return (jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref }) }));\n}\n\nexport { PopChild };\n"],"names":["PopChildMeasure","React","prevProps","element","size","PopChild","children","isPresent","id","useId","ref","useRef","nonce","useContext","MotionConfigContext","useInsertionEffect","width","height","top","left","style","jsx"],"mappings":"6NAUA,MAAMA,UAAwBC,EAAM,SAAU,CAC1C,wBAAwBC,EAAW,CAC/B,MAAMC,EAAU,KAAK,MAAM,SAAS,QACpC,GAAIA,GAAWD,EAAU,WAAa,CAAC,KAAK,MAAM,UAAW,CACzD,MAAME,EAAO,KAAK,MAAM,QAAQ,QAChCA,EAAK,OAASD,EAAQ,cAAgB,EACtCC,EAAK,MAAQD,EAAQ,aAAe,EACpCC,EAAK,IAAMD,EAAQ,UACnBC,EAAK,KAAOD,EAAQ,UACxB,CACA,OAAO,IACX,CAIA,oBAAqB,CAAE,CACvB,QAAS,CACL,OAAO,KAAK,MAAM,QACtB,CACJ,CACA,SAASE,EAAS,CAAE,SAAAC,EAAU,UAAAC,GAAa,CACvC,MAAMC,EAAKC,EAAK,EACVC,EAAMC,EAAO,IAAI,EACjBP,EAAOO,EAAO,CAChB,MAAO,EACP,OAAQ,EACR,IAAK,EACL,KAAM,CACd,CAAK,EACK,CAAE,MAAAC,CAAK,EAAKC,EAAWC,CAAmB,EAUhD,OAAAC,EAAmB,IAAM,CACrB,KAAM,CAAE,MAAAC,EAAO,OAAAC,EAAQ,IAAAC,EAAK,KAAAC,CAAI,EAAKf,EAAK,QAC1C,GAAIG,GAAa,CAACG,EAAI,SAAW,CAACM,GAAS,CAACC,EACxC,OACJP,EAAI,QAAQ,QAAQ,YAAcF,EAClC,MAAMY,EAAQ,SAAS,cAAc,OAAO,EAC5C,OAAIR,IACAQ,EAAM,MAAQR,GAClB,SAAS,KAAK,YAAYQ,CAAK,EAC3BA,EAAM,OACNA,EAAM,MAAM,WAAW;AAAA,iCACFZ,CAAE;AAAA;AAAA,qBAEdQ,CAAK;AAAA,sBACJC,CAAM;AAAA,mBACTC,CAAG;AAAA,oBACFC,CAAI;AAAA;AAAA,SAEf,EAEM,IAAM,CACT,SAAS,KAAK,YAAYC,CAAK,CACnC,CACJ,EAAG,CAACb,CAAS,CAAC,EACNc,EAAIrB,EAAiB,CAAE,UAAWO,EAAW,SAAUG,EAAK,QAASN,EAAM,SAAUH,EAAM,aAAaK,EAAU,CAAE,IAAAI,CAAG,CAAE,EAAG,CACxI","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.js.map

@@ -1 +1 @@
-{"version":3,"file":"PresenceChild.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs"],"sourcesContent":["\"use client\";\nimport { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useCallback, useMemo } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PopChild } from './PopChild.mjs';\n\nconst PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, }) => {\n    const presenceChildren = useConstant(newChildrenMap);\n    const id = useId();\n    const memoizedOnExitComplete = useCallback((childId) => {\n        presenceChildren.set(childId, true);\n        for (const isComplete of presenceChildren.values()) {\n            if (!isComplete)\n                return; // can stop searching when any is incomplete\n        }\n        onExitComplete && onExitComplete();\n    }, [presenceChildren, onExitComplete]);\n    const context = useMemo(() => ({\n        id,\n        initial,\n        isPresent,\n        custom,\n        onExitComplete: memoizedOnExitComplete,\n        register: (childId) => {\n            presenceChildren.set(childId, false);\n            return () => presenceChildren.delete(childId);\n        },\n    }), \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout\n        ? [Math.random(), memoizedOnExitComplete]\n        : [isPresent, memoizedOnExitComplete]);\n    useMemo(() => {\n        presenceChildren.forEach((_, key) => presenceChildren.set(key, false));\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React.useEffect(() => {\n        !isPresent &&\n            !presenceChildren.size &&\n            onExitComplete &&\n            onExitComplete();\n    }, [isPresent]);\n    if (mode === \"popLayout\") {\n        children = jsx(PopChild, { isPresent: isPresent, children: children });\n    }\n    return (jsx(PresenceContext.Provider, { value: context, children: children }));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nexport { PresenceChild };\n"],"names":["PresenceChild","children","initial","isPresent","onExitComplete","custom","presenceAffectsLayout","mode","presenceChildren","useConstant","newChildrenMap","id","useId","memoizedOnExitComplete","useCallback","childId","isComplete","context","useMemo","_","key","React","jsx","PopChild","PresenceContext"],"mappings":"kSAQK,MAACA,EAAgB,CAAC,CAAE,SAAAC,EAAU,QAAAC,EAAS,UAAAC,EAAW,eAAAC,EAAgB,OAAAC,EAAQ,sBAAAC,EAAuB,KAAAC,KAAY,CAC9G,MAAMC,EAAmBC,EAAYC,CAAc,EAC7CC,EAAKC,EAAK,EACVC,EAAyBC,EAAaC,GAAY,CACpDP,EAAiB,IAAIO,EAAS,EAAI,EAClC,UAAWC,KAAcR,EAAiB,SACtC,GAAI,CAACQ,EACD,OAERZ,GAAkBA,EAAc,CACxC,EAAO,CAACI,EAAkBJ,CAAc,CAAC,EAC/Ba,EAAUC,EAAQ,KAAO,CAC3B,GAAAP,EACA,QAAAT,EACA,UAAAC,EACA,OAAAE,EACA,eAAgBQ,EAChB,SAAWE,IACPP,EAAiB,IAAIO,EAAS,EAAK,EAC5B,IAAMP,EAAiB,OAAOO,CAAO,EAExD,GAMIT,EACM,CAAC,KAAK,OAAM,EAAIO,CAAsB,EACtC,CAACV,EAAWU,CAAsB,CAAC,EACzC,OAAAK,EAAQ,IAAM,CACVV,EAAiB,QAAQ,CAACW,EAAGC,IAAQZ,EAAiB,IAAIY,EAAK,EAAK,CAAC,CAC7E,EAAO,CAACjB,CAAS,CAAC,EAKdkB,EAAM,UAAU,IAAM,CAClB,CAAClB,GACG,CAACK,EAAiB,MAClBJ,GACAA,EAAc,CAC1B,EAAO,CAACD,CAAS,CAAC,EACVI,IAAS,cACTN,EAAWqB,EAAIC,EAAU,CAAE,UAAWpB,EAAW,SAAUF,EAAU,GAEjEqB,EAAIE,EAAgB,SAAU,CAAE,MAAOP,EAAS,SAAUhB,EAAU,CAChF,EACA,SAASS,GAAiB,CACtB,OAAO,IAAI,GACf","x_google_ignoreList":[0]}
+{"version":3,"file":"PresenceChild.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs"],"sourcesContent":["\"use client\";\nimport { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useCallback, useMemo } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PopChild } from './PopChild.mjs';\n\nconst PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, }) => {\n    const presenceChildren = useConstant(newChildrenMap);\n    const id = useId();\n    const memoizedOnExitComplete = useCallback((childId) => {\n        presenceChildren.set(childId, true);\n        for (const isComplete of presenceChildren.values()) {\n            if (!isComplete)\n                return; // can stop searching when any is incomplete\n        }\n        onExitComplete && onExitComplete();\n    }, [presenceChildren, onExitComplete]);\n    const context = useMemo(() => ({\n        id,\n        initial,\n        isPresent,\n        custom,\n        onExitComplete: memoizedOnExitComplete,\n        register: (childId) => {\n            presenceChildren.set(childId, false);\n            return () => presenceChildren.delete(childId);\n        },\n    }), \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout\n        ? [Math.random(), memoizedOnExitComplete]\n        : [isPresent, memoizedOnExitComplete]);\n    useMemo(() => {\n        presenceChildren.forEach((_, key) => presenceChildren.set(key, false));\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React.useEffect(() => {\n        !isPresent &&\n            !presenceChildren.size &&\n            onExitComplete &&\n            onExitComplete();\n    }, [isPresent]);\n    if (mode === \"popLayout\") {\n        children = jsx(PopChild, { isPresent: isPresent, children: children });\n    }\n    return (jsx(PresenceContext.Provider, { value: context, children: children }));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nexport { PresenceChild };\n"],"names":["PresenceChild","children","initial","isPresent","onExitComplete","custom","presenceAffectsLayout","mode","presenceChildren","useConstant","newChildrenMap","id","useId","memoizedOnExitComplete","useCallback","childId","isComplete","context","useMemo","_","key","React","jsx","PopChild","PresenceContext"],"mappings":"kSAQK,MAACA,EAAgB,CAAC,CAAE,SAAAC,EAAU,QAAAC,EAAS,UAAAC,EAAW,eAAAC,EAAgB,OAAAC,EAAQ,sBAAAC,EAAuB,KAAAC,KAAY,CAC9G,MAAMC,EAAmBC,EAAYC,CAAc,EAC7CC,EAAKC,EAAK,EACVC,EAAyBC,EAAaC,GAAY,CACpDP,EAAiB,IAAIO,EAAS,EAAI,EAClC,UAAWC,KAAcR,EAAiB,SACtC,GAAI,CAACQ,EACD,OAERZ,GAAkBA,EAAc,CACpC,EAAG,CAACI,EAAkBJ,CAAc,CAAC,EAC/Ba,EAAUC,EAAQ,KAAO,CAC3B,GAAAP,EACA,QAAAT,EACA,UAAAC,EACA,OAAAE,EACA,eAAgBQ,EAChB,SAAWE,IACPP,EAAiB,IAAIO,EAAS,EAAK,EAC5B,IAAMP,EAAiB,OAAOO,CAAO,EAExD,GAMIT,EACM,CAAC,KAAK,OAAM,EAAIO,CAAsB,EACtC,CAACV,EAAWU,CAAsB,CAAC,EACzC,OAAAK,EAAQ,IAAM,CACVV,EAAiB,QAAQ,CAACW,EAAGC,IAAQZ,EAAiB,IAAIY,EAAK,EAAK,CAAC,CACzE,EAAG,CAACjB,CAAS,CAAC,EAKdkB,EAAM,UAAU,IAAM,CAClB,CAAClB,GACG,CAACK,EAAiB,MAClBJ,GACAA,EAAc,CACtB,EAAG,CAACD,CAAS,CAAC,EACVI,IAAS,cACTN,EAAWqB,EAAIC,EAAU,CAAE,UAAWpB,EAAW,SAAUF,EAAU,GAEjEqB,EAAIE,EAAgB,SAAU,CAAE,MAAOP,EAAS,SAAUhB,EAAU,CAChF,EACA,SAASS,GAAiB,CACtB,OAAO,IAAI,GACf","x_google_ignoreList":[0]}

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs"],"sourcesContent":["\"use client\";\nimport { jsx, Fragment } from 'react/jsx-runtime';\nimport { useMemo, useRef, useState, useContext } from 'react';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PresenceChild } from './PresenceChild.mjs';\nimport { usePresence } from './use-presence.mjs';\nimport { onlyElements, getChildKey } from './utils.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\n\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nconst AnimatePresence = ({ children, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = \"sync\", propagate = false, }) => {\n    const [isParentPresent, safeToRemove] = usePresence(propagate);\n    /**\n     * Filter any children that aren't ReactElements. We can only track components\n     * between renders with a props.key.\n     */\n    const presentChildren = useMemo(() => onlyElements(children), [children]);\n    /**\n     * Track the keys of the currently rendered children. This is used to\n     * determine which children are exiting.\n     */\n    const presentKeys = propagate && !isParentPresent ? [] : presentChildren.map(getChildKey);\n    /**\n     * If `initial={false}` we only want to pass this to components in the first render.\n     */\n    const isInitialRender = useRef(true);\n    /**\n     * A ref containing the currently present children. When all exit animations\n     * are complete, we use this to re-render the component with the latest children\n     * *committed* rather than the latest children *rendered*.\n     */\n    const pendingPresentChildren = useRef(presentChildren);\n    /**\n     * Track which exiting children have finished animating out.\n     */\n    const exitComplete = useConstant(() => new Map());\n    /**\n     * Save children to render as React state. To ensure this component is concurrent-safe,\n     * we check for exiting children via an effect.\n     */\n    const [diffedChildren, setDiffedChildren] = useState(presentChildren);\n    const [renderedChildren, setRenderedChildren] = useState(presentChildren);\n    useIsomorphicLayoutEffect(() => {\n        isInitialRender.current = false;\n        pendingPresentChildren.current = presentChildren;\n        /**\n         * Update complete status of exiting children.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const key = getChildKey(renderedChildren[i]);\n            if (!presentKeys.includes(key)) {\n                if (exitComplete.get(key) !== true) {\n                    exitComplete.set(key, false);\n                }\n            }\n            else {\n                exitComplete.delete(key);\n            }\n        }\n    }, [renderedChildren, presentKeys.length, presentKeys.join(\"-\")]);\n    const exitingChildren = [];\n    if (presentChildren !== diffedChildren) {\n        let nextChildren = [...presentChildren];\n        /**\n         * Loop through all the currently rendered components and decide which\n         * are exiting.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const child = renderedChildren[i];\n            const key = getChildKey(child);\n            if (!presentKeys.includes(key)) {\n                nextChildren.splice(i, 0, child);\n                exitingChildren.push(child);\n            }\n        }\n        /**\n         * If we're in \"wait\" mode, and we have exiting children, we want to\n         * only render these until they've all exited.\n         */\n        if (mode === \"wait\" && exitingChildren.length) {\n            nextChildren = exitingChildren;\n        }\n        setRenderedChildren(onlyElements(nextChildren));\n        setDiffedChildren(presentChildren);\n        /**\n         * Early return to ensure once we've set state with the latest diffed\n         * children, we can immediately re-render.\n         */\n        return;\n    }\n    if (process.env.NODE_ENV !== \"production\" &&\n        mode === \"wait\" &&\n        renderedChildren.length > 1) {\n        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to \"wait\". This will lead to odd visual behaviour.`);\n    }\n    /**\n     * If we've been provided a forceRender function by the LayoutGroupContext,\n     * we can use it to force a re-render amongst all surrounding components once\n     * all components have finished animating out.\n     */\n    const { forceRender } = useContext(LayoutGroupContext);\n    return (jsx(Fragment, { children: renderedChildren.map((child) => {\n            const key = getChildKey(child);\n            const isPresent = propagate && !isParentPresent\n                ? false\n                : presentChildren === renderedChildren ||\n                    presentKeys.includes(key);\n            const onExit = () => {\n                if (exitComplete.has(key)) {\n                    exitComplete.set(key, true);\n                }\n                else {\n                    return;\n                }\n                let isEveryExitComplete = true;\n                exitComplete.forEach((isExitComplete) => {\n                    if (!isExitComplete)\n                        isEveryExitComplete = false;\n                });\n                if (isEveryExitComplete) {\n                    forceRender === null || forceRender === void 0 ? void 0 : forceRender();\n                    setRenderedChildren(pendingPresentChildren.current);\n                    propagate && (safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove());\n                    onExitComplete && onExitComplete();\n                }\n            };\n            return (jsx(PresenceChild, { isPresent: isPresent, initial: !isInitialRender.current || initial\n                    ? undefined\n                    : false, custom: isPresent ? undefined : custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode, onExitComplete: isPresent ? undefined : onExit, children: child }, key));\n        }) }));\n};\n\nexport { AnimatePresence };\n"],"names":["AnimatePresence","children","custom","initial","onExitComplete","presenceAffectsLayout","mode","propagate","isParentPresent","safeToRemove","usePresence","presentChildren","useMemo","onlyElements","presentKeys","getChildKey","isInitialRender","useRef","pendingPresentChildren","exitComplete","useConstant","diffedChildren","setDiffedChildren","useState","renderedChildren","setRenderedChildren","useIsomorphicLayoutEffect","i","key","exitingChildren","nextChildren","child","forceRender","useContext","LayoutGroupContext","jsx","Fragment","isPresent","onExit","isEveryExitComplete","isExitComplete","PresenceChild"],"mappings":"kfA2CA,MAAMA,EAAkB,CAAC,CAAE,SAAAC,EAAU,OAAAC,EAAQ,QAAAC,EAAU,GAAM,eAAAC,EAAgB,sBAAAC,EAAwB,GAAM,KAAAC,EAAO,OAAQ,UAAAC,EAAY,MAAa,CAC/I,KAAM,CAACC,EAAiBC,CAAY,EAAIC,EAAYH,CAAS,EAKvDI,EAAkBC,EAAQ,IAAMC,EAAaZ,CAAQ,EAAG,CAACA,CAAQ,CAAC,EAKlEa,EAAcP,GAAa,CAACC,EAAkB,CAAA,EAAKG,EAAgB,IAAII,CAAW,EAIlFC,EAAkBC,EAAO,EAAI,EAM7BC,EAAyBD,EAAON,CAAe,EAI/CQ,EAAeC,EAAY,IAAM,IAAI,GAAK,EAK1C,CAACC,EAAgBC,CAAiB,EAAIC,EAASZ,CAAe,EAC9D,CAACa,EAAkBC,CAAmB,EAAIF,EAASZ,CAAe,EACxEe,EAA0B,IAAM,CAC5BV,EAAgB,QAAU,GAC1BE,EAAuB,QAAUP,EAIjC,QAASgB,EAAI,EAAGA,EAAIH,EAAiB,OAAQG,IAAK,CAC9C,MAAMC,EAAMb,EAAYS,EAAiBG,CAAC,CAAC,EACtCb,EAAY,SAASc,CAAG,EAMzBT,EAAa,OAAOS,CAAG,EALnBT,EAAa,IAAIS,CAAG,IAAM,IAC1BT,EAAa,IAAIS,EAAK,EAAK,CAKnC,CACJ,EACD,CAACJ,EAAkBV,EAAY,OAAQA,EAAY,KAAK,GAAG,CAAC,CAAC,EAChE,MAAMe,EAAkB,CAAA,EACxB,GAAIlB,IAAoBU,EAAgB,CACpC,IAAIS,EAAe,CAAC,GAAGnB,CAAe,EAKtC,QAASgB,EAAI,EAAGA,EAAIH,EAAiB,OAAQG,IAAK,CAC9C,MAAMI,EAAQP,EAAiBG,CAAC,EAC1BC,EAAMb,EAAYgB,CAAK,EACxBjB,EAAY,SAASc,CAAG,IACzBE,EAAa,OAAOH,EAAG,EAAGI,CAAK,EAC/BF,EAAgB,KAAKE,CAAK,EAC9B,CAMAzB,IAAS,QAAUuB,EAAgB,SACnCC,EAAeD,GAEnBJ,EAAoBZ,EAAaiB,CAAY,CAAC,EAC9CR,EAAkBX,CAAe,EAKjC,MAAA,CAYJ,KAAM,CAAE,YAAAqB,CAAA,EAAgBC,EAAWC,CAAkB,EACrD,OAAQC,EAAIC,EAAU,CAAE,SAAUZ,EAAiB,IAAKO,GAAU,CAC1D,MAAMH,EAAMb,EAAYgB,CAAK,EACvBM,EAAY9B,GAAa,CAACC,EAC1B,GACAG,IAAoBa,GAClBV,EAAY,SAASc,CAAG,EAC1BU,EAAS,IAAM,CACjB,GAAInB,EAAa,IAAIS,CAAG,EACpBT,EAAa,IAAIS,EAAK,EAAI,MAG1B,QAEJ,IAAIW,EAAsB,GAC1BpB,EAAa,QAASqB,GAAmB,CAChCA,IACDD,EAAsB,GAAA,CAC7B,EACGA,IACAP,GAAgB,MAA0CA,EAAA,EAC1DP,EAAoBP,EAAuB,OAAO,EAClDX,IAAcE,GAAiB,MAA2CA,KAC1EL,GAAkBA,EAAA,EACtB,EAEJ,OAAQ+B,EAAIM,EAAe,CAAE,UAAAJ,EAAsB,QAAS,CAACrB,EAAgB,SAAWb,EAC9E,OACA,GAAO,OAAQkC,EAAY,OAAYnC,EAAQ,sBAAAG,EAA8C,KAAAC,EAAY,eAAgB+B,EAAY,OAAYC,EAAQ,SAAUP,CAAA,EAASH,CAAG,CAAA,CAC5L,EAAG,CACZ","x_google_ignoreList":[0]}
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs"],"sourcesContent":["\"use client\";\nimport { jsx, Fragment } from 'react/jsx-runtime';\nimport { useMemo, useRef, useState, useContext } from 'react';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PresenceChild } from './PresenceChild.mjs';\nimport { usePresence } from './use-presence.mjs';\nimport { onlyElements, getChildKey } from './utils.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\n\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nconst AnimatePresence = ({ children, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = \"sync\", propagate = false, }) => {\n    const [isParentPresent, safeToRemove] = usePresence(propagate);\n    /**\n     * Filter any children that aren't ReactElements. We can only track components\n     * between renders with a props.key.\n     */\n    const presentChildren = useMemo(() => onlyElements(children), [children]);\n    /**\n     * Track the keys of the currently rendered children. This is used to\n     * determine which children are exiting.\n     */\n    const presentKeys = propagate && !isParentPresent ? [] : presentChildren.map(getChildKey);\n    /**\n     * If `initial={false}` we only want to pass this to components in the first render.\n     */\n    const isInitialRender = useRef(true);\n    /**\n     * A ref containing the currently present children. When all exit animations\n     * are complete, we use this to re-render the component with the latest children\n     * *committed* rather than the latest children *rendered*.\n     */\n    const pendingPresentChildren = useRef(presentChildren);\n    /**\n     * Track which exiting children have finished animating out.\n     */\n    const exitComplete = useConstant(() => new Map());\n    /**\n     * Save children to render as React state. To ensure this component is concurrent-safe,\n     * we check for exiting children via an effect.\n     */\n    const [diffedChildren, setDiffedChildren] = useState(presentChildren);\n    const [renderedChildren, setRenderedChildren] = useState(presentChildren);\n    useIsomorphicLayoutEffect(() => {\n        isInitialRender.current = false;\n        pendingPresentChildren.current = presentChildren;\n        /**\n         * Update complete status of exiting children.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const key = getChildKey(renderedChildren[i]);\n            if (!presentKeys.includes(key)) {\n                if (exitComplete.get(key) !== true) {\n                    exitComplete.set(key, false);\n                }\n            }\n            else {\n                exitComplete.delete(key);\n            }\n        }\n    }, [renderedChildren, presentKeys.length, presentKeys.join(\"-\")]);\n    const exitingChildren = [];\n    if (presentChildren !== diffedChildren) {\n        let nextChildren = [...presentChildren];\n        /**\n         * Loop through all the currently rendered components and decide which\n         * are exiting.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const child = renderedChildren[i];\n            const key = getChildKey(child);\n            if (!presentKeys.includes(key)) {\n                nextChildren.splice(i, 0, child);\n                exitingChildren.push(child);\n            }\n        }\n        /**\n         * If we're in \"wait\" mode, and we have exiting children, we want to\n         * only render these until they've all exited.\n         */\n        if (mode === \"wait\" && exitingChildren.length) {\n            nextChildren = exitingChildren;\n        }\n        setRenderedChildren(onlyElements(nextChildren));\n        setDiffedChildren(presentChildren);\n        /**\n         * Early return to ensure once we've set state with the latest diffed\n         * children, we can immediately re-render.\n         */\n        return;\n    }\n    if (process.env.NODE_ENV !== \"production\" &&\n        mode === \"wait\" &&\n        renderedChildren.length > 1) {\n        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to \"wait\". This will lead to odd visual behaviour.`);\n    }\n    /**\n     * If we've been provided a forceRender function by the LayoutGroupContext,\n     * we can use it to force a re-render amongst all surrounding components once\n     * all components have finished animating out.\n     */\n    const { forceRender } = useContext(LayoutGroupContext);\n    return (jsx(Fragment, { children: renderedChildren.map((child) => {\n            const key = getChildKey(child);\n            const isPresent = propagate && !isParentPresent\n                ? false\n                : presentChildren === renderedChildren ||\n                    presentKeys.includes(key);\n            const onExit = () => {\n                if (exitComplete.has(key)) {\n                    exitComplete.set(key, true);\n                }\n                else {\n                    return;\n                }\n                let isEveryExitComplete = true;\n                exitComplete.forEach((isExitComplete) => {\n                    if (!isExitComplete)\n                        isEveryExitComplete = false;\n                });\n                if (isEveryExitComplete) {\n                    forceRender === null || forceRender === void 0 ? void 0 : forceRender();\n                    setRenderedChildren(pendingPresentChildren.current);\n                    propagate && (safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove());\n                    onExitComplete && onExitComplete();\n                }\n            };\n            return (jsx(PresenceChild, { isPresent: isPresent, initial: !isInitialRender.current || initial\n                    ? undefined\n                    : false, custom: isPresent ? undefined : custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode, onExitComplete: isPresent ? undefined : onExit, children: child }, key));\n        }) }));\n};\n\nexport { AnimatePresence };\n"],"names":["AnimatePresence","children","custom","initial","onExitComplete","presenceAffectsLayout","mode","propagate","isParentPresent","safeToRemove","usePresence","presentChildren","useMemo","onlyElements","presentKeys","getChildKey","isInitialRender","useRef","pendingPresentChildren","exitComplete","useConstant","diffedChildren","setDiffedChildren","useState","renderedChildren","setRenderedChildren","useIsomorphicLayoutEffect","i","key","exitingChildren","nextChildren","child","forceRender","useContext","LayoutGroupContext","jsx","Fragment","isPresent","onExit","isEveryExitComplete","isExitComplete","PresenceChild"],"mappings":"kfA2CA,MAAMA,EAAkB,CAAC,CAAE,SAAAC,EAAU,OAAAC,EAAQ,QAAAC,EAAU,GAAM,eAAAC,EAAgB,sBAAAC,EAAwB,GAAM,KAAAC,EAAO,OAAQ,UAAAC,EAAY,MAAa,CAC/I,KAAM,CAACC,EAAiBC,CAAY,EAAIC,EAAYH,CAAS,EAKvDI,EAAkBC,EAAQ,IAAMC,EAAaZ,CAAQ,EAAG,CAACA,CAAQ,CAAC,EAKlEa,EAAcP,GAAa,CAACC,EAAkB,CAAA,EAAKG,EAAgB,IAAII,CAAW,EAIlFC,EAAkBC,EAAO,EAAI,EAM7BC,EAAyBD,EAAON,CAAe,EAI/CQ,EAAeC,EAAY,IAAM,IAAI,GAAK,EAK1C,CAACC,EAAgBC,CAAiB,EAAIC,EAASZ,CAAe,EAC9D,CAACa,EAAkBC,CAAmB,EAAIF,EAASZ,CAAe,EACxEe,EAA0B,IAAM,CAC5BV,EAAgB,QAAU,GAC1BE,EAAuB,QAAUP,EAIjC,QAASgB,EAAI,EAAGA,EAAIH,EAAiB,OAAQG,IAAK,CAC9C,MAAMC,EAAMb,EAAYS,EAAiBG,CAAC,CAAC,EACtCb,EAAY,SAASc,CAAG,EAMzBT,EAAa,OAAOS,CAAG,EALnBT,EAAa,IAAIS,CAAG,IAAM,IAC1BT,EAAa,IAAIS,EAAK,EAAK,CAMvC,CACJ,EAAG,CAACJ,EAAkBV,EAAY,OAAQA,EAAY,KAAK,GAAG,CAAC,CAAC,EAChE,MAAMe,EAAkB,CAAA,EACxB,GAAIlB,IAAoBU,EAAgB,CACpC,IAAIS,EAAe,CAAC,GAAGnB,CAAe,EAKtC,QAASgB,EAAI,EAAGA,EAAIH,EAAiB,OAAQG,IAAK,CAC9C,MAAMI,EAAQP,EAAiBG,CAAC,EAC1BC,EAAMb,EAAYgB,CAAK,EACxBjB,EAAY,SAASc,CAAG,IACzBE,EAAa,OAAOH,EAAG,EAAGI,CAAK,EAC/BF,EAAgB,KAAKE,CAAK,EAElC,CAKIzB,IAAS,QAAUuB,EAAgB,SACnCC,EAAeD,GAEnBJ,EAAoBZ,EAAaiB,CAAY,CAAC,EAC9CR,EAAkBX,CAAe,EAKjC,MACJ,CAWA,KAAM,CAAE,YAAAqB,CAAA,EAAgBC,EAAWC,CAAkB,EACrD,OAAQC,EAAIC,EAAU,CAAE,SAAUZ,EAAiB,IAAKO,GAAU,CAC1D,MAAMH,EAAMb,EAAYgB,CAAK,EACvBM,EAAY9B,GAAa,CAACC,EAC1B,GACAG,IAAoBa,GAClBV,EAAY,SAASc,CAAG,EAC1BU,EAAS,IAAM,CACjB,GAAInB,EAAa,IAAIS,CAAG,EACpBT,EAAa,IAAIS,EAAK,EAAI,MAG1B,QAEJ,IAAIW,EAAsB,GAC1BpB,EAAa,QAASqB,GAAmB,CAChCA,IACDD,EAAsB,GAC9B,CAAC,EACGA,IACAP,GAAgB,MAA0CA,EAAA,EAC1DP,EAAoBP,EAAuB,OAAO,EAClDX,IAAcE,GAAiB,MAA2CA,KAC1EL,GAAkBA,EAAA,EAE1B,EACA,OAAQ+B,EAAIM,EAAe,CAAE,UAAAJ,EAAsB,QAAS,CAACrB,EAAgB,SAAWb,EAC9E,OACA,GAAO,OAAQkC,EAAY,OAAYnC,EAAQ,sBAAAG,EAA8C,KAAAC,EAAY,eAAgB+B,EAAY,OAAYC,EAAQ,SAAUP,CAAA,EAASH,CAAG,CAC7L,CAAC,EAAG,CACZ","x_google_ignoreList":[0]}