@viswa-test/creative-workspace-ui-component 0.0.44 → 0.0.46

package/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.mjs.js

@@ -1,2 +0,0 @@
-import{time as e}from"../frameloop/sync-time.mjs.js";import{JSAnimation as t}from"./JSAnimation.mjs.js";import{getFinalKeyframe as i}from"./keyframes/get-final.mjs.js";import{KeyframeResolver as s,flushKeyframeResolvers as n}from"./keyframes/KeyframesResolver.mjs.js";import{NativeAnimationExtended as a}from"./NativeAnimationExtended.mjs.js";import{canAnimate as o}from"./utils/can-animate.mjs.js";import{makeAnimationInstant as m}from"./utils/make-animation-instant.mjs.js";import{WithPromise as r}from"./utils/WithPromise.mjs.js";import{supportsBrowserAnimation as l}from"./waapi/supports/waapi.mjs.js";import{MotionGlobalConfig as h}from"../../../../motion-utils/dist/es/global-config.mjs.js";import{noop as p}from"../../../../motion-utils/dist/es/noop.mjs.js";class f extends r{constructor({autoplay:t=!0,delay:i=0,type:n="keyframes",repeat:a=0,repeatDelay:o=0,repeatType:m="loop",keyframes:r,name:l,motionValue:h,element:p,...f}){super(),this.stop=()=>{this._animation&&(this._animation.stop(),this.stopTimeline?.()),this.keyframeResolver?.cancel()},this.createdAt=e.now();const d={autoplay:t,delay:i,type:n,repeat:a,repeatDelay:o,repeatType:m,name:l,motionValue:h,element:p,...f},y=p?.KeyframeResolver||s;this.keyframeResolver=new y(r,(e,t,i)=>this.onKeyframesResolved(e,t,d,!i),l,h,p),this.keyframeResolver?.scheduleResolve()}onKeyframesResolved(s,n,r,f){this.keyframeResolver=void 0;const{name:d,type:y,velocity:c,delay:u,isHandoff:j,onUpdate:v}=r;this.resolvedAt=e.now();let g=!0;o(s,d,y,c)||(g=!1,!h.instantAnimations&&u||v?.(i(s,r,n)),s[0]=s[s.length-1],m(r),r.repeat=0);const T={startTime:f?this.resolvedAt&&this.resolvedAt-this.createdAt>40?this.resolvedAt:this.createdAt:void 0,finalKeyframe:n,...r,keyframes:s},k=g&&!j&&l(T),R=T.motionValue?.owner?.current;let A;if(k)try{A=new a({...T,element:R})}catch{A=new t(T)}else A=new t(T);A.finished.then(()=>{this.notifyFinished()}).catch(p),this.pendingTimeline&&(this.stopTimeline=A.attachTimeline(this.pendingTimeline),this.pendingTimeline=void 0),this._animation=A}get finished(){return this._animation?this.animation.finished:this._finished}then(e,t){return this.finished.finally(e).then(()=>{})}get animation(){return this._animation||(this.keyframeResolver?.resume(),n()),this._animation}get duration(){return this.animation.duration}get iterationDuration(){return this.animation.iterationDuration}get time(){return this.animation.time}set time(e){this.animation.time=e}get speed(){return this.animation.speed}get state(){return this.animation.state}set speed(e){this.animation.speed=e}get startTime(){return this.animation.startTime}attachTimeline(e){return this._animation?this.stopTimeline=this.animation.attachTimeline(e):this.pendingTimeline=e,()=>this.stop()}play(){this.animation.play()}pause(){this.animation.pause()}complete(){this.animation.complete()}cancel(){this._animation&&this.animation.cancel(),this.keyframeResolver?.cancel()}}export{f as AsyncMotionValueAnimation};
-//# sourceMappingURL=AsyncMotionValueAnimation.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AsyncMotionValueAnimation.mjs.js","sources":["../../../../../../node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.mjs"],"sourcesContent":["import { MotionGlobalConfig, noop } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { JSAnimation } from './JSAnimation.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { KeyframeResolver, flushKeyframeResolvers } from './keyframes/KeyframesResolver.mjs';\nimport { NativeAnimationExtended } from './NativeAnimationExtended.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { makeAnimationInstant } from './utils/make-animation-instant.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\nimport { supportsBrowserAnimation } from './waapi/supports/waapi.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 AsyncMotionValueAnimation extends WithPromise {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", keyframes, name, motionValue, element, ...options }) {\n        super();\n        /**\n         * Bound to support return animation.stop pattern\n         */\n        this.stop = () => {\n            if (this._animation) {\n                this._animation.stop();\n                this.stopTimeline?.();\n            }\n            this.keyframeResolver?.cancel();\n        };\n        this.createdAt = time.now();\n        const optionsWithDefaults = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            name,\n            motionValue,\n            element,\n            ...options,\n        };\n        const KeyframeResolver$1 = element?.KeyframeResolver || KeyframeResolver;\n        this.keyframeResolver = new KeyframeResolver$1(keyframes, (resolvedKeyframes, finalKeyframe, forced) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe, optionsWithDefaults, !forced), name, motionValue, element);\n        this.keyframeResolver?.scheduleResolve();\n    }\n    onKeyframesResolved(keyframes, finalKeyframe, options, sync) {\n        this.keyframeResolver = undefined;\n        const { name, type, velocity, delay, isHandoff, onUpdate } = options;\n        this.resolvedAt = time.now();\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        let canAnimateValue = true;\n        if (!canAnimate(keyframes, name, type, velocity)) {\n            canAnimateValue = false;\n            if (MotionGlobalConfig.instantAnimations || !delay) {\n                onUpdate?.(getFinalKeyframe(keyframes, options, finalKeyframe));\n            }\n            keyframes[0] = keyframes[keyframes.length - 1];\n            makeAnimationInstant(options);\n            options.repeat = 0;\n        }\n        /**\n         * Resolve startTime for the animation.\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 committed frame, we prefer to use resolvedAt\n         * to avoid a sudden jump into the animation.\n         */\n        const startTime = sync\n            ? !this.resolvedAt\n                ? this.createdAt\n                : this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY\n                    ? this.resolvedAt\n                    : this.createdAt\n            : undefined;\n        const resolvedOptions = {\n            startTime,\n            finalKeyframe,\n            ...options,\n            keyframes,\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         * Also skip WAAPI when keyframes aren't animatable, as the resolved\n         * values may not be valid CSS and would trigger browser warnings.\n         */\n        const useWaapi = canAnimateValue &&\n            !isHandoff &&\n            supportsBrowserAnimation(resolvedOptions);\n        const element = resolvedOptions.motionValue?.owner?.current;\n        let animation;\n        if (useWaapi) {\n            try {\n                animation = new NativeAnimationExtended({\n                    ...resolvedOptions,\n                    element,\n                });\n            }\n            catch {\n                animation = new JSAnimation(resolvedOptions);\n            }\n        }\n        else {\n            animation = new JSAnimation(resolvedOptions);\n        }\n        animation.finished.then(() => {\n            this.notifyFinished();\n        }).catch(noop);\n        if (this.pendingTimeline) {\n            this.stopTimeline = animation.attachTimeline(this.pendingTimeline);\n            this.pendingTimeline = undefined;\n        }\n        this._animation = animation;\n    }\n    get finished() {\n        if (!this._animation) {\n            return this._finished;\n        }\n        else {\n            return this.animation.finished;\n        }\n    }\n    then(onResolve, _onReject) {\n        return this.finished.finally(onResolve).then(() => { });\n    }\n    get animation() {\n        if (!this._animation) {\n            this.keyframeResolver?.resume();\n            flushKeyframeResolvers();\n        }\n        return this._animation;\n    }\n    get duration() {\n        return this.animation.duration;\n    }\n    get iterationDuration() {\n        return this.animation.iterationDuration;\n    }\n    get time() {\n        return this.animation.time;\n    }\n    set time(newTime) {\n        this.animation.time = newTime;\n    }\n    get speed() {\n        return this.animation.speed;\n    }\n    get state() {\n        return this.animation.state;\n    }\n    set speed(newSpeed) {\n        this.animation.speed = newSpeed;\n    }\n    get startTime() {\n        return this.animation.startTime;\n    }\n    attachTimeline(timeline) {\n        if (this._animation) {\n            this.stopTimeline = this.animation.attachTimeline(timeline);\n        }\n        else {\n            this.pendingTimeline = timeline;\n        }\n        return () => this.stop();\n    }\n    play() {\n        this.animation.play();\n    }\n    pause() {\n        this.animation.pause();\n    }\n    complete() {\n        this.animation.complete();\n    }\n    cancel() {\n        if (this._animation) {\n            this.animation.cancel();\n        }\n        this.keyframeResolver?.cancel();\n    }\n}\n\nexport { AsyncMotionValueAnimation };\n//# sourceMappingURL=AsyncMotionValueAnimation.mjs.map\n"],"names":["AsyncMotionValueAnimation","WithPromise","constructor","autoplay","delay","type","repeat","repeatDelay","repeatType","keyframes","name","motionValue","element","options","super","this","stop","_animation","stopTimeline","keyframeResolver","cancel","createdAt","time","now","optionsWithDefaults","KeyframeResolver$1","KeyframeResolver","resolvedKeyframes","finalKeyframe","forced","onKeyframesResolved","scheduleResolve","sync","undefined","velocity","isHandoff","onUpdate","resolvedAt","canAnimateValue","canAnimate","MotionGlobalConfig","instantAnimations","getFinalKeyframe","length","makeAnimationInstant","resolvedOptions","startTime","useWaapi","supportsBrowserAnimation","owner","current","animation","NativeAnimationExtended","JSAnimation","finished","then","notifyFinished","catch","noop","pendingTimeline","attachTimeline","_finished","onResolve","_onReject","finally","resume","flushKeyframeResolvers","duration","iterationDuration","newTime","speed","state","newSpeed","timeline","play","pause","complete"],"mappings":"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"}

package/dist/node_modules/motion-dom/dist/es/animation/JSAnimation.mjs.js

@@ -1,2 +0,0 @@
-import{time as t}from"../frameloop/sync-time.mjs.js";import{mix as i}from"../utils/mix/index.mjs.js";import{frameloopDriver as e}from"./drivers/frame.mjs.js";import{inertia as s}from"./generators/inertia.mjs.js";import{keyframes as r}from"./generators/keyframes.mjs.js";import{calcGeneratorDuration as o}from"./generators/utils/calc-duration.mjs.js";import{getGeneratorVelocity as n}from"./generators/utils/velocity.mjs.js";import{getFinalKeyframe as a}from"./keyframes/get-final.mjs.js";import{replaceTransitionType as h}from"./utils/replace-transition-type.mjs.js";import{WithPromise as m}from"./utils/WithPromise.mjs.js";import{invariant as l}from"../../../../motion-utils/dist/es/errors.mjs.js";import{pipe as p}from"../../../../motion-utils/dist/es/pipe.mjs.js";import{millisecondsToSeconds as d,secondsToMilliseconds as u}from"../../../../motion-utils/dist/es/time-conversion.mjs.js";import{clamp as c}from"../../../../motion-utils/dist/es/clamp.mjs.js";const T=t=>t/100;class y extends m{constructor(i){super(),this.state="idle",this.startTime=null,this.isStopped=!1,this.currentTime=0,this.holdTime=null,this.playbackSpeed=1,this.delayState={done:!1,value:void 0},this.stop=()=>{const{motionValue:i}=this.options;i&&i.updatedAt!==t.now()&&this.tick(t.now()),this.isStopped=!0,"idle"!==this.state&&(this.teardown(),this.options.onStop?.())},this.options=i,this.initAnimation(),this.play(),!1===i.autoplay&&this.pause()}initAnimation(){const{options:t}=this;h(t);const{type:e=r,repeat:s=0,repeatDelay:n=0,repeatType:a,velocity:m=0}=t;let{keyframes:d}=t;const u=e||r;"production"!==process.env.NODE_ENV&&u!==r&&l(d.length<=2,`Only two keyframes currently supported with spring and inertia animations. Trying to animate ${d}`,"spring-two-frames"),u!==r&&"number"!=typeof d[0]&&(this.mixKeyframes=p(T,i(d[0],d[1])),d=[0,100]);const c=u({...t,keyframes:d});"mirror"===a&&(this.mirroredGenerator=u({...t,keyframes:[...d].reverse(),velocity:-m})),null===c.calculatedDuration&&(c.calculatedDuration=o(c));const{calculatedDuration:y}=c;this.calculatedDuration=y,this.resolvedDuration=y+n,this.totalDuration=this.resolvedDuration*(s+1)-n,this.generator=c}updateTime(t){const i=Math.round(t-this.startTime)*this.playbackSpeed;null!==this.holdTime?this.currentTime=this.holdTime:this.currentTime=i}tick(t,i=!1){const{generator:e,totalDuration:r,mixKeyframes:o,mirroredGenerator:n,resolvedDuration:h,calculatedDuration:m}=this;if(null===this.startTime)return e.next(0);const{delay:l=0,keyframes:p,repeat:d,repeatType:u,repeatDelay:T,type:y,onUpdate:f,finalKeyframe:v}=this.options;this.speed>0?this.startTime=Math.min(this.startTime,t):this.speed<0&&(this.startTime=Math.min(t-r/this.speed,this.startTime)),i?this.currentTime=t:this.updateTime(t);const j=this.currentTime-l*(this.playbackSpeed>=0?1:-1),k=this.playbackSpeed>=0?j<0:j>r;this.currentTime=Math.max(j,0),"finished"===this.state&&null===this.holdTime&&(this.currentTime=r);let g,D=this.currentTime,S=e;if(d){const t=Math.min(this.currentTime,r)/h;let i=Math.floor(t),e=t%1;!e&&t>=1&&(e=1),1===e&&i--,i=Math.min(i,d+1);Boolean(i%2)&&("reverse"===u?(e=1-e,T&&(e-=T/h)):"mirror"===u&&(S=n)),D=c(0,1,e)*h}k?(this.delayState.value=p[0],g=this.delayState):g=S.next(D),o&&!k&&(g.value=o(g.value));let{done:w}=g;k||null===m||(w=this.playbackSpeed>=0?this.currentTime>=r:this.currentTime<=0);const b=null===this.holdTime&&("finished"===this.state||"running"===this.state&&w);return b&&y!==s&&(g.value=a(p,this.options,v,this.speed)),f&&f(g.value),b&&this.finish(),g}then(t,i){return this.finished.then(t,i)}get duration(){return d(this.calculatedDuration)}get iterationDuration(){const{delay:t=0}=this.options||{};return this.duration+d(t)}get time(){return d(this.currentTime)}set time(t){t=u(t),this.currentTime=t,null===this.startTime||null!==this.holdTime||0===this.playbackSpeed?this.holdTime=t:this.driver&&(this.startTime=this.driver.now()-t/this.playbackSpeed),this.driver?this.driver.start(!1):(this.startTime=0,this.state="paused",this.holdTime=t,this.tick(t))}getGeneratorVelocity(){const t=this.currentTime;if(t<=0)return this.options.velocity||0;if(this.generator.velocity)return this.generator.velocity(t);const i=this.generator.next(t).value;return n(t=>this.generator.next(t).value,t,i)}get speed(){return this.playbackSpeed}set speed(i){const e=this.playbackSpeed!==i;e&&this.driver&&this.updateTime(t.now()),this.playbackSpeed=i,e&&this.driver&&(this.time=d(this.currentTime))}play(){if(this.isStopped)return;const{driver:t=e,startTime:i}=this.options;this.driver||(this.driver=t(t=>this.tick(t))),this.options.onPlay?.();const s=this.driver.now();"finished"===this.state?(this.updateFinished(),this.startTime=s):null!==this.holdTime?this.startTime=s-this.holdTime:this.startTime||(this.startTime=i??s),"finished"===this.state&&this.speed<0&&(this.startTime+=this.calculatedDuration),this.holdTime=null,this.state="running",this.driver.start()}pause(){this.state="paused",this.updateTime(t.now()),this.holdTime=this.currentTime}complete(){"running"!==this.state&&this.play(),this.state="finished",this.holdTime=null}finish(){this.notifyFinished(),this.teardown(),this.state="finished",this.options.onComplete?.()}cancel(){this.holdTime=null,this.startTime=0,this.tick(0),this.teardown(),this.options.onCancel?.()}teardown(){this.state="idle",this.stopDriver(),this.startTime=this.holdTime=null}stopDriver(){this.driver&&(this.driver.stop(),this.driver=void 0)}sample(t){return this.startTime=0,this.tick(t,!0)}attachTimeline(t){return this.options.allowFlatten&&(this.options.type="keyframes",this.options.ease="linear",this.initAnimation()),this.driver?.stop(),t.observe(this)}}export{y as JSAnimation};
-//# sourceMappingURL=JSAnimation.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/JSAnimation.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"JSAnimation.mjs.js","sources":["../../../../../../node_modules/motion-dom/dist/es/animation/JSAnimation.mjs"],"sourcesContent":["import { invariant, pipe, clamp, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { mix } from '../utils/mix/index.mjs';\nimport { frameloopDriver } from './drivers/frame.mjs';\nimport { inertia } from './generators/inertia.mjs';\nimport { keyframes } from './generators/keyframes.mjs';\nimport { calcGeneratorDuration } from './generators/utils/calc-duration.mjs';\nimport { getGeneratorVelocity } from './generators/utils/velocity.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\n\nconst percentToProgress = (percent) => percent / 100;\nclass JSAnimation extends WithPromise {\n    constructor(options) {\n        super();\n        this.state = \"idle\";\n        this.startTime = null;\n        this.isStopped = false;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * Reusable state object for the delay phase to avoid\n         * allocating a new object every frame.\n         */\n        this.delayState = {\n            done: false,\n            value: undefined,\n        };\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            const { motionValue } = this.options;\n            if (motionValue && motionValue.updatedAt !== time.now()) {\n                this.tick(time.now());\n            }\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            this.options.onStop?.();\n        };\n        this.options = options;\n        this.initAnimation();\n        this.play();\n        if (options.autoplay === false)\n            this.pause();\n    }\n    initAnimation() {\n        const { options } = this;\n        replaceTransitionType(options);\n        const { type = keyframes, repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = options;\n        let { keyframes: keyframes$1 } = options;\n        const generatorFactory = type || keyframes;\n        if (process.env.NODE_ENV !== \"production\" &&\n            generatorFactory !== keyframes) {\n            invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`, \"spring-two-frames\");\n        }\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            this.mixKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...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            this.mirroredGenerator = generatorFactory({\n                ...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        this.calculatedDuration = calculatedDuration;\n        this.resolvedDuration = calculatedDuration + repeatDelay;\n        this.totalDuration = this.resolvedDuration * (repeat + 1) - repeatDelay;\n        this.generator = generator;\n    }\n    updateTime(timestamp) {\n        const animationTime = Math.round(timestamp - this.startTime) * this.playbackSpeed;\n        // Update currentTime\n        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 = animationTime;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { generator, totalDuration, mixKeyframes, mirroredGenerator, resolvedDuration, calculatedDuration, } = this;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay = 0, keyframes, repeat, repeatType, repeatDelay, type, onUpdate, finalKeyframe, } = 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        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else {\n            this.updateTime(timestamp);\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.playbackSpeed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.playbackSpeed >= 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        let state;\n        if (isInDelayPhase) {\n            this.delayState.value = keyframes[0];\n            state = this.delayState;\n        }\n        else {\n            state = frameGenerator.next(elapsed);\n        }\n        if (mixKeyframes && !isInDelayPhase) {\n            state.value = mixKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.playbackSpeed >= 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        // TODO: The exception for inertia could be cleaner here\n        if (isAnimationFinished && type !== inertia) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\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.finished.then(resolve, reject);\n    }\n    get duration() {\n        return millisecondsToSeconds(this.calculatedDuration);\n    }\n    get iterationDuration() {\n        const { delay = 0 } = this.options || {};\n        return this.duration + millisecondsToSeconds(delay);\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.startTime === null ||\n            this.holdTime !== null ||\n            this.playbackSpeed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.playbackSpeed;\n        }\n        if (this.driver) {\n            this.driver.start(false);\n        }\n        else {\n            this.startTime = 0;\n            this.state = \"paused\";\n            this.holdTime = newTime;\n            this.tick(newTime);\n        }\n    }\n    /**\n     * Returns the generator's velocity at the current time in units/second.\n     * Uses the analytical derivative when available (springs), avoiding\n     * the MotionValue's frame-dependent velocity estimation.\n     */\n    getGeneratorVelocity() {\n        const t = this.currentTime;\n        if (t <= 0)\n            return this.options.velocity || 0;\n        if (this.generator.velocity) {\n            return this.generator.velocity(t);\n        }\n        // Fallback: finite difference\n        const current = this.generator.next(t).value;\n        return getGeneratorVelocity((s) => this.generator.next(s).value, t, current);\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        if (hasChanged && this.driver) {\n            this.updateTime(time.now());\n        }\n        this.playbackSpeed = newSpeed;\n        if (hasChanged && this.driver) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, startTime } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        this.options.onPlay?.();\n        const now = this.driver.now();\n        if (this.state === \"finished\") {\n            this.updateFinished();\n            this.startTime = now;\n        }\n        else if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = startTime ?? now;\n        }\n        if (this.state === \"finished\" && this.speed < 0) {\n            this.startTime += this.calculatedDuration;\n        }\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        this.state = \"paused\";\n        this.updateTime(time.now());\n        this.holdTime = this.currentTime;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.notifyFinished();\n        this.teardown();\n        this.state = \"finished\";\n        this.options.onComplete?.();\n    }\n    cancel() {\n        this.holdTime = null;\n        this.startTime = 0;\n        this.tick(0);\n        this.teardown();\n        this.options.onCancel?.();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.startTime = this.holdTime = null;\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(sampleTime) {\n        this.startTime = 0;\n        return this.tick(sampleTime, true);\n    }\n    attachTimeline(timeline) {\n        if (this.options.allowFlatten) {\n            this.options.type = \"keyframes\";\n            this.options.ease = \"linear\";\n            this.initAnimation();\n        }\n        this.driver?.stop();\n        return timeline.observe(this);\n    }\n}\n// Legacy function support\nfunction animateValue(options) {\n    return new JSAnimation(options);\n}\n\nexport { JSAnimation, animateValue };\n//# sourceMappingURL=JSAnimation.mjs.map\n"],"names":["percentToProgress","percent","JSAnimation","WithPromise","constructor","options","super","this","state","startTime","isStopped","currentTime","holdTime","playbackSpeed","delayState","done","value","undefined","stop","motionValue","updatedAt","time","now","tick","teardown","onStop","initAnimation","play","autoplay","pause","replaceTransitionType","type","keyframes","repeat","repeatDelay","repeatType","velocity","keyframes$1","generatorFactory","process","env","NODE_ENV","invariant","length","mixKeyframes","pipe","mix","generator","mirroredGenerator","reverse","calculatedDuration","calcGeneratorDuration","resolvedDuration","totalDuration","updateTime","timestamp","animationTime","Math","round","sample","next","delay","onUpdate","finalKeyframe","speed","min","timeWithoutDelay","isInDelayPhase","max","elapsed","frameGenerator","progress","currentIteration","floor","iterationProgress","Boolean","clamp","isAnimationFinished","inertia","getFinalKeyframe","finish","then","resolve","reject","finished","duration","millisecondsToSeconds","iterationDuration","newTime","secondsToMilliseconds","driver","start","getGeneratorVelocity","t","current","s","newSpeed","hasChanged","frameloopDriver","onPlay","updateFinished","complete","notifyFinished","onComplete","cancel","onCancel","stopDriver","sampleTime","attachTimeline","timeline","allowFlatten","ease","observe"],"mappings":"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"}

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimation.mjs.js

@@ -1,2 +0,0 @@
-import{setStyle as t}from"../render/dom/style-set.mjs.js";import{supportsScrollTimeline as i}from"../utils/supports/scroll-timeline.mjs.js";import{getFinalKeyframe as e}from"./keyframes/get-final.mjs.js";import{WithPromise as s}from"./utils/WithPromise.mjs.js";import{startWaapiAnimation as n}from"./waapi/start-waapi-animation.mjs.js";import{applyGeneratorOptions as a}from"./waapi/utils/apply-generator.mjs.js";import{invariant as o}from"../../../../motion-utils/dist/es/errors.mjs.js";import{millisecondsToSeconds as m,secondsToMilliseconds as r}from"../../../../motion-utils/dist/es/time-conversion.mjs.js";import{noop as h}from"../../../../motion-utils/dist/es/noop.mjs.js";class l extends s{constructor(i){if(super(),this.finishedTime=null,this.isStopped=!1,this.manualStartTime=null,!i)return;const{element:s,name:m,keyframes:r,pseudoElement:h,allowFlatten:l=!1,finalKeyframe:u,onComplete:p}=i;this.isPseudoElement=Boolean(h),this.allowFlatten=l,this.options=i,o("string"!=typeof i.type,'Mini animate() doesn\'t support "type" as a string.',"mini-spring");const d=a(i);this.animation=n(s,m,r,d,h),!1===d.autoplay&&this.animation.pause(),this.animation.onfinish=()=>{if(this.finishedTime=this.time,!h){const i=e(r,this.options,u,this.speed);this.updateMotionValue&&this.updateMotionValue(i),t(s,m,i),this.animation.cancel()}p?.(),this.notifyFinished()}}play(){this.isStopped||(this.manualStartTime=null,this.animation.play(),"finished"===this.state&&this.updateFinished())}pause(){this.animation.pause()}complete(){this.animation.finish?.()}cancel(){try{this.animation.cancel()}catch(t){}}stop(){if(this.isStopped)return;this.isStopped=!0;const{state:t}=this;"idle"!==t&&"finished"!==t&&(this.updateMotionValue?this.updateMotionValue():this.commitStyles(),this.isPseudoElement||this.cancel())}commitStyles(){const t=this.options?.element;!this.isPseudoElement&&t?.isConnected&&this.animation.commitStyles?.()}get duration(){const t=this.animation.effect?.getComputedTiming?.().duration||0;return m(Number(t))}get iterationDuration(){const{delay:t=0}=this.options||{};return this.duration+m(t)}get time(){return m(Number(this.animation.currentTime)||0)}set time(t){const i=null!==this.finishedTime;this.manualStartTime=null,this.finishedTime=null,this.animation.currentTime=r(t),i&&this.animation.pause()}get speed(){return this.animation.playbackRate}set speed(t){t<0&&(this.finishedTime=null),this.animation.playbackRate=t}get state(){return null!==this.finishedTime?"finished":this.animation.playState}get startTime(){return this.manualStartTime??Number(this.animation.startTime)}set startTime(t){this.manualStartTime=this.animation.startTime=t}attachTimeline({timeline:t,rangeStart:e,rangeEnd:s,observe:n}){return this.allowFlatten&&this.animation.effect?.updateTiming({easing:"linear"}),this.animation.onfinish=null,t&&i()?(this.animation.timeline=t,e&&(this.animation.rangeStart=e),s&&(this.animation.rangeEnd=s),h):n(this)}}export{l as NativeAnimation};
-//# sourceMappingURL=NativeAnimation.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimation.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NativeAnimation.mjs.js","sources":["../../../../../../node_modules/motion-dom/dist/es/animation/NativeAnimation.mjs"],"sourcesContent":["import { invariant, millisecondsToSeconds, secondsToMilliseconds, noop } from 'motion-utils';\nimport { setStyle } from '../render/dom/style-set.mjs';\nimport { supportsScrollTimeline } from '../utils/supports/scroll-timeline.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\nimport { startWaapiAnimation } from './waapi/start-waapi-animation.mjs';\nimport { applyGeneratorOptions } from './waapi/utils/apply-generator.mjs';\n\n/**\n * NativeAnimation implements AnimationPlaybackControls for the browser's Web Animations API.\n */\nclass NativeAnimation extends WithPromise {\n    constructor(options) {\n        super();\n        this.finishedTime = null;\n        this.isStopped = false;\n        /**\n         * Tracks a manually-set start time that takes precedence over WAAPI's\n         * dynamic startTime. This is cleared when play() or time setter is called,\n         * allowing WAAPI to take over timing.\n         */\n        this.manualStartTime = null;\n        if (!options)\n            return;\n        const { element, name, keyframes, pseudoElement, allowFlatten = false, finalKeyframe, onComplete, } = options;\n        this.isPseudoElement = Boolean(pseudoElement);\n        this.allowFlatten = allowFlatten;\n        this.options = options;\n        invariant(typeof options.type !== \"string\", `Mini animate() doesn't support \"type\" as a string.`, \"mini-spring\");\n        const transition = applyGeneratorOptions(options);\n        this.animation = startWaapiAnimation(element, name, keyframes, transition, pseudoElement);\n        if (transition.autoplay === false) {\n            this.animation.pause();\n        }\n        this.animation.onfinish = () => {\n            this.finishedTime = this.time;\n            if (!pseudoElement) {\n                const keyframe = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);\n                if (this.updateMotionValue) {\n                    this.updateMotionValue(keyframe);\n                }\n                /**\n                 * If we can, we want to commit the final style as set by the user,\n                 * rather than the computed keyframe value supplied by the animation.\n                 * We always do this, even when a motion value is present, to prevent\n                 * a visual flash in Firefox where the WAAPI animation's fill is removed\n                 * during cancel() before the scheduled render can apply the correct value.\n                 */\n                setStyle(element, name, keyframe);\n                this.animation.cancel();\n            }\n            onComplete?.();\n            this.notifyFinished();\n        };\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        this.manualStartTime = null;\n        this.animation.play();\n        if (this.state === \"finished\") {\n            this.updateFinished();\n        }\n    }\n    pause() {\n        this.animation.pause();\n    }\n    complete() {\n        this.animation.finish?.();\n    }\n    cancel() {\n        try {\n            this.animation.cancel();\n        }\n        catch (e) { }\n    }\n    stop() {\n        if (this.isStopped)\n            return;\n        this.isStopped = true;\n        const { state } = this;\n        if (state === \"idle\" || state === \"finished\") {\n            return;\n        }\n        if (this.updateMotionValue) {\n            this.updateMotionValue();\n        }\n        else {\n            this.commitStyles();\n        }\n        if (!this.isPseudoElement)\n            this.cancel();\n    }\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * In this method, we commit styles back to the DOM before cancelling\n     * the animation.\n     *\n     * This is designed to be overridden by NativeAnimationExtended, which\n     * will create a renderless JS animation and sample it twice to calculate\n     * its current value, \"previous\" value, and therefore allow\n     * Motion to also correctly calculate velocity for any subsequent animation\n     * while deferring the commit until the next animation frame.\n     */\n    commitStyles() {\n        const element = this.options?.element;\n        if (!this.isPseudoElement && element?.isConnected) {\n            this.animation.commitStyles?.();\n        }\n    }\n    get duration() {\n        const duration = this.animation.effect?.getComputedTiming?.().duration || 0;\n        return millisecondsToSeconds(Number(duration));\n    }\n    get iterationDuration() {\n        const { delay = 0 } = this.options || {};\n        return this.duration + millisecondsToSeconds(delay);\n    }\n    get time() {\n        return millisecondsToSeconds(Number(this.animation.currentTime) || 0);\n    }\n    set time(newTime) {\n        const wasFinished = this.finishedTime !== null;\n        this.manualStartTime = null;\n        this.finishedTime = null;\n        this.animation.currentTime = secondsToMilliseconds(newTime);\n        if (wasFinished) {\n            this.animation.pause();\n        }\n    }\n    /**\n     * The playback speed of the animation.\n     * 1 = normal speed, 2 = double speed, 0.5 = half speed.\n     */\n    get speed() {\n        return this.animation.playbackRate;\n    }\n    set speed(newSpeed) {\n        // Allow backwards playback after finishing\n        if (newSpeed < 0)\n            this.finishedTime = null;\n        this.animation.playbackRate = newSpeed;\n    }\n    get state() {\n        return this.finishedTime !== null\n            ? \"finished\"\n            : this.animation.playState;\n    }\n    get startTime() {\n        return this.manualStartTime ?? Number(this.animation.startTime);\n    }\n    set startTime(newStartTime) {\n        this.manualStartTime = this.animation.startTime = newStartTime;\n    }\n    /**\n     * Attaches a timeline to the animation, for instance the `ScrollTimeline`.\n     */\n    attachTimeline({ timeline, rangeStart, rangeEnd, observe, }) {\n        if (this.allowFlatten) {\n            this.animation.effect?.updateTiming({ easing: \"linear\" });\n        }\n        this.animation.onfinish = null;\n        if (timeline && supportsScrollTimeline()) {\n            this.animation.timeline = timeline;\n            if (rangeStart)\n                this.animation.rangeStart = rangeStart;\n            if (rangeEnd)\n                this.animation.rangeEnd = rangeEnd;\n            return noop;\n        }\n        else {\n            return observe(this);\n        }\n    }\n}\n\nexport { NativeAnimation };\n//# sourceMappingURL=NativeAnimation.mjs.map\n"],"names":["NativeAnimation","WithPromise","constructor","options","super","this","finishedTime","isStopped","manualStartTime","element","name","keyframes","pseudoElement","allowFlatten","finalKeyframe","onComplete","isPseudoElement","Boolean","invariant","type","transition","applyGeneratorOptions","animation","startWaapiAnimation","autoplay","pause","onfinish","time","keyframe","getFinalKeyframe","speed","updateMotionValue","setStyle","cancel","notifyFinished","play","state","updateFinished","complete","finish","e","stop","commitStyles","isConnected","duration","effect","getComputedTiming","millisecondsToSeconds","Number","iterationDuration","delay","currentTime","newTime","wasFinished","secondsToMilliseconds","playbackRate","newSpeed","playState","startTime","newStartTime","attachTimeline","timeline","rangeStart","rangeEnd","observe","updateTiming","easing","supportsScrollTimeline","noop"],"mappings":"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"}

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs.js

@@ -1,2 +0,0 @@
-import{time as t}from"../frameloop/sync-time.mjs.js";import{setStyle as o}from"../render/dom/style-set.mjs.js";import{JSAnimation as s}from"./JSAnimation.mjs.js";import{NativeAnimation as i}from"./NativeAnimation.mjs.js";import{replaceTransitionType as e}from"./utils/replace-transition-type.mjs.js";import{replaceStringEasing as m}from"./waapi/utils/unsupported-easing.mjs.js";import{clamp as a}from"../../../../motion-utils/dist/es/clamp.mjs.js";class r extends i{constructor(t){m(t),e(t),super(t),void 0!==t.startTime&&!1!==t.autoplay&&(this.startTime=t.startTime),this.options=t}updateMotionValue(i){const{motionValue:e,onUpdate:m,onComplete:r,element:n,...p}=this.options;if(!e)return;if(void 0!==i)return void e.set(i);const l=new s({...p,autoplay:!1}),u=Math.max(10,t.now()-this.startTime),j=a(0,10,u-10),d=l.sample(u).value,{name:f}=this.options;n&&f&&o(n,f,d),e.setWithVelocity(l.sample(Math.max(0,u-j)).value,d,j),l.stop()}}export{r as NativeAnimationExtended};
-//# sourceMappingURL=NativeAnimationExtended.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NativeAnimationExtended.mjs.js","sources":["../../../../../../node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs"],"sourcesContent":["import { clamp } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { setStyle } from '../render/dom/style-set.mjs';\nimport { JSAnimation } from './JSAnimation.mjs';\nimport { NativeAnimation } from './NativeAnimation.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { replaceStringEasing } from './waapi/utils/unsupported-easing.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\nclass NativeAnimationExtended extends NativeAnimation {\n    constructor(options) {\n        /**\n         * The base NativeAnimation function only supports a subset\n         * of Motion easings, and WAAPI also only supports some\n         * easing functions via string/cubic-bezier definitions.\n         *\n         * This function replaces those unsupported easing functions\n         * with a JS easing function. This will later get compiled\n         * to a linear() easing function.\n         */\n        replaceStringEasing(options);\n        /**\n         * Ensure we replace the transition type with a generator function\n         * before passing to WAAPI.\n         *\n         * TODO: Does this have a better home? It could be shared with\n         * JSAnimation.\n         */\n        replaceTransitionType(options);\n        super(options);\n        /**\n         * Only set startTime when the animation should autoplay.\n         * Setting startTime on a paused WAAPI animation unpauses it\n         * (per the WAAPI spec), which breaks autoplay: false.\n         */\n        if (options.startTime !== undefined && options.autoplay !== false) {\n            this.startTime = options.startTime;\n        }\n        this.options = options;\n    }\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * Rather than read committed 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    updateMotionValue(value) {\n        const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n        if (!motionValue)\n            return;\n        if (value !== undefined) {\n            motionValue.set(value);\n            return;\n        }\n        const sampleAnimation = new JSAnimation({\n            ...options,\n            autoplay: false,\n        });\n        /**\n         * Use wall-clock elapsed time for sampling.\n         * Under CPU load, WAAPI's currentTime may not reflect actual\n         * elapsed time, causing incorrect sampling and visual jumps.\n         */\n        const sampleTime = Math.max(sampleDelta, time.now() - this.startTime);\n        const delta = clamp(0, sampleDelta, sampleTime - sampleDelta);\n        const current = sampleAnimation.sample(sampleTime).value;\n        /**\n         * Write the estimated value to inline style so it persists\n         * after cancel(), covering the async gap before the next\n         * animation starts.\n         */\n        const { name } = this.options;\n        if (element && name)\n            setStyle(element, name, current);\n        motionValue.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current, delta);\n        sampleAnimation.stop();\n    }\n}\n\nexport { NativeAnimationExtended };\n//# sourceMappingURL=NativeAnimationExtended.mjs.map\n"],"names":["NativeAnimationExtended","NativeAnimation","constructor","options","replaceStringEasing","replaceTransitionType","super","undefined","startTime","autoplay","this","updateMotionValue","value","motionValue","onUpdate","onComplete","element","set","sampleAnimation","JSAnimation","sampleTime","Math","max","time","now","delta","clamp","current","sample","name","setStyle","setWithVelocity","stop"],"mappings":"gcAcA,MAAMA,UAAgCC,EAClC,WAAAC,CAAYC,GAURC,EAAoBD,GAQpBE,EAAsBF,GACtBG,MAAMH,QAMoBI,IAAtBJ,EAAQK,YAAgD,IAArBL,EAAQM,WAC3CC,KAAKF,UAAYL,EAAQK,WAE7BE,KAAKP,QAAUA,CAClB,CASD,iBAAAQ,CAAkBC,GACd,MAAMC,YAAEA,EAAWC,SAAEA,EAAQC,WAAEA,EAAUC,QAAEA,KAAYb,GAAYO,KAAKP,QACxE,IAAKU,EACD,OACJ,QAAcN,IAAVK,EAEA,YADAC,EAAYI,IAAIL,GAGpB,MAAMM,EAAkB,IAAIC,EAAY,IACjChB,EACHM,UAAU,IAORW,EAAaC,KAAKC,IAzDZ,GAyD6BC,EAAKC,MAAQd,KAAKF,WACrDiB,EAAQC,EAAM,EA1DR,GA0DwBN,EA1DxB,IA2DNO,EAAUT,EAAgBU,OAAOR,GAAYR,OAM7CiB,KAAEA,GAASnB,KAAKP,QAClBa,GAAWa,GACXC,EAASd,EAASa,EAAMF,GAC5Bd,EAAYkB,gBAAgBb,EAAgBU,OAAOP,KAAKC,IAAI,EAAGF,EAAaK,IAAQb,MAAOe,EAASF,GACpGP,EAAgBc,MACnB"}

package/dist/node_modules/motion-dom/dist/es/animation/animate/single-value.mjs.js

@@ -1,2 +0,0 @@
-import{animateMotionValue as o}from"../interfaces/motion-value.mjs.js";import{motionValue as t}from"../../value/index.mjs.js";import{isMotionValue as i}from"../../value/utils/is-motion-value.mjs.js";function m(m,r,s){const n=i(m)?m:t(m);return n.start(o("",n,r,s)),n.animation}export{m as animateSingleValue};
-//# sourceMappingURL=single-value.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/animate/single-value.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"single-value.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/animate/single-value.mjs"],"sourcesContent":["import { animateMotionValue } from '../interfaces/motion-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction animateSingleValue(value, keyframes, options) {\n    const motionValue$1 = isMotionValue(value) ? value : motionValue(value);\n    motionValue$1.start(animateMotionValue(\"\", motionValue$1, keyframes, options));\n    return motionValue$1.animation;\n}\n\nexport { animateSingleValue };\n//# sourceMappingURL=single-value.mjs.map\n"],"names":["animateSingleValue","value","keyframes","options","motionValue$1","isMotionValue","motionValue","start","animateMotionValue","animation"],"mappings":"uMAIA,SAASA,EAAmBC,EAAOC,EAAWC,GAC1C,MAAMC,EAAgBC,EAAcJ,GAASA,EAAQK,EAAYL,GAEjE,OADAG,EAAcG,MAAMC,EAAmB,GAAIJ,EAAeF,EAAWC,IAC9DC,EAAcK,SACzB"}

package/dist/node_modules/motion-dom/dist/es/animation/drivers/frame.mjs.js

@@ -1,2 +0,0 @@
-import{time as o}from"../../frameloop/sync-time.mjs.js";import{frame as t,cancelFrame as m,frameData as s}from"../../frameloop/frame.mjs.js";const r=r=>{const e=({timestamp:o})=>r(o);return{start:(o=!0)=>t.update(e,o),stop:()=>m(e),now:()=>s.isProcessing?s.timestamp:o.now()}};export{r as frameloopDriver};
-//# sourceMappingURL=frame.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/drivers/frame.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"frame.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/drivers/frame.mjs"],"sourcesContent":["import { time } from '../../frameloop/sync-time.mjs';\nimport { frameData, cancelFrame, frame } from '../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: (keepAlive = true) => frame.update(passTimestamp, keepAlive),\n        stop: () => cancelFrame(passTimestamp),\n        /**\n         * If we're processing this frame we can use the\n         * framelocked timestamp to keep things in sync.\n         */\n        now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),\n    };\n};\n\nexport { frameloopDriver };\n//# sourceMappingURL=frame.mjs.map\n"],"names":["frameloopDriver","update","passTimestamp","timestamp","start","keepAlive","frame","stop","cancelFrame","now","frameData","isProcessing","time"],"mappings":"6IAGK,MAACA,EAAmBC,IACrB,MAAMC,EAAgB,EAAGC,eAAgBF,EAAOE,GAChD,MAAO,CACHC,MAAO,CAACC,GAAY,IAASC,EAAML,OAAOC,EAAeG,GACzDE,KAAM,IAAMC,EAAYN,GAKxBO,IAAK,IAAOC,EAAUC,aAAeD,EAAUP,UAAYS,EAAKH"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/inertia.mjs.js

@@ -1,2 +0,0 @@
-import{spring as e}from"./spring.mjs.js";import{getGeneratorVelocity as t}from"./utils/velocity.mjs.js";function o({keyframes:o,velocity:a=0,power:n=.8,timeConstant:s=325,bounceDamping:i=10,bounceStiffness:r=500,modifyTarget:l,min:v,max:d,restDelta:u=.5,restSpeed:m}){const c=o[0],f={done:!1,value:c},p=e=>void 0===v?d:void 0===d||Math.abs(v-e)<Math.abs(d-e)?v:d;let y=n*a;const b=c+y,x=void 0===l?b:l(b);x!==b&&(y=x-c);const g=e=>-y*Math.exp(-e/s),h=e=>x+g(e),j=e=>{const t=g(e),o=h(e);f.done=Math.abs(t)<=u,f.value=f.done?x:o};let D,M;const S=o=>{var a;(a=f.value,void 0!==v&&a<v||void 0!==d&&a>d)&&(D=o,M=e({keyframes:[f.value,p(f.value)],velocity:t(h,o,f.value),damping:i,stiffness:r,restDelta:u,restSpeed:m}))};return S(0),{calculatedDuration:null,next:e=>{let t=!1;return M||void 0!==D||(t=!0,j(e),S(e)),void 0!==D&&e>=D?M.next(e-D):(!t&&j(e),f)}}}export{o as inertia};
-//# sourceMappingURL=inertia.mjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"inertia.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/generators/inertia.mjs"],"sourcesContent":["import { spring } from './spring.mjs';\nimport { getGeneratorVelocity } 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: getGeneratorVelocity(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//# sourceMappingURL=inertia.mjs.map\n"],"names":["inertia","keyframes","velocity","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","min","max","restDelta","restSpeed","origin","state","done","value","nearestBoundary","v","undefined","Math","abs","amplitude","ideal","target","calcDelta","t","exp","calcLatest","applyFriction","delta","latest","timeReachedBoundary","spring$1","checkCatchBoundary","spring","getGeneratorVelocity","damping","stiffness","calculatedDuration","next","hasUpdatedFrame"],"mappings":"wGAGA,SAASA,GAAQC,UAAEA,EAASC,SAAEA,EAAW,EAAGC,MAAEA,EAAQ,GAAGC,aAAEA,EAAe,IAAGC,cAAEA,EAAgB,GAAEC,gBAAEA,EAAkB,IAAGC,aAAEA,EAAYC,IAAEA,EAAGC,IAAEA,EAAGC,UAAEA,EAAY,GAAGC,UAAEA,IAC/J,MAAMC,EAASX,EAAU,GACnBY,EAAQ,CACVC,MAAM,EACNC,MAAOH,GAGLI,EAAmBC,QACTC,IAARV,EACOC,OACCS,IAART,GAEGU,KAAKC,IAAIZ,EAAMS,GAAKE,KAAKC,IAAIX,EAAMQ,GAD/BT,EAC0CC,EAEzD,IAAIY,EAAYlB,EAAQD,EACxB,MAAMoB,EAAQV,EAASS,EACjBE,OAA0BL,IAAjBX,EAA6Be,EAAQf,EAAae,GAK7DC,IAAWD,IACXD,EAAYE,EAASX,GACzB,MAAMY,EAAaC,IAAOJ,EAAYF,KAAKO,KAAKD,EAAIrB,GAC9CuB,EAAcF,GAAMF,EAASC,EAAUC,GACvCG,EAAiBH,IACnB,MAAMI,EAAQL,EAAUC,GAClBK,EAASH,EAAWF,GAC1BZ,EAAMC,KAAOK,KAAKC,IAAIS,IAAUnB,EAChCG,EAAME,MAAQF,EAAMC,KAAOS,EAASO,GAQxC,IAAIC,EACAC,EACJ,MAAMC,EAAsBR,IAjCN,IAACR,KAkCAJ,EAAME,WAlCSG,IAARV,GAAqBS,EAAIT,QAAiBU,IAART,GAAqBQ,EAAIR,KAoCrFsB,EAAsBN,EACtBO,EAAWE,EAAO,CACdjC,UAAW,CAACY,EAAME,MAAOC,EAAgBH,EAAME,QAC/Cb,SAAUiC,EAAqBR,EAAYF,EAAGZ,EAAME,OACpDqB,QAAS/B,EACTgC,UAAW/B,EACXI,YACAC,gBAIR,OADAsB,EAAmB,GACZ,CACHK,mBAAoB,KACpBC,KAAOd,IAOH,IAAIe,GAAkB,EAUtB,OATKR,QAAoCd,IAAxBa,IACbS,GAAkB,EAClBZ,EAAcH,GACdQ,EAAmBR,SAMKP,IAAxBa,GAAqCN,GAAKM,EACnCC,EAASO,KAAKd,EAAIM,KAGxBS,GAAmBZ,EAAcH,GAC3BZ,IAIvB"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs.js

@@ -1,2 +0,0 @@
-import{interpolate as s}from"../../utils/interpolate.mjs.js";import{defaultOffset as e}from"../keyframes/offsets/default.mjs.js";import{convertOffsetToTimes as t}from"../keyframes/offsets/time.mjs.js";import{isEasingArray as i}from"../../../../../motion-utils/dist/es/easing/utils/is-easing-array.mjs.js";import{easingDefinitionToFunction as m}from"../../../../../motion-utils/dist/es/easing/utils/map.mjs.js";import{easeInOut as o}from"../../../../../motion-utils/dist/es/easing/ease.mjs.js";function r(s,e){return s.map(()=>e||o).splice(0,s.length-1)}function a({duration:o=300,keyframes:a,times:n,ease:u="easeInOut"}){const f=i(u)?u.map(m):m(u),l={done:!1,value:a[0]},j=t(n&&n.length===a.length?n:e(a),o),p=s(j,a,{ease:Array.isArray(f)?f:r(a,f)});return{calculatedDuration:o,next:s=>(l.value=p(s),l.done=s>=o,l)}}export{r as defaultEasing,a as keyframes};
-//# sourceMappingURL=keyframes.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyframes.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs"],"sourcesContent":["import { easeInOut, isEasingArray, easingDefinitionToFunction } from 'motion-utils';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../keyframes/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../keyframes/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n//# sourceMappingURL=keyframes.mjs.map\n"],"names":["defaultEasing","values","easing","map","easeInOut","splice","length","keyframes","duration","keyframeValues","times","ease","easingFunctions","isEasingArray","easingDefinitionToFunction","state","done","value","absoluteTimes","convertOffsetToTimes","defaultOffset","mapTimeToKeyframe","interpolate","Array","isArray","calculatedDuration","next","t"],"mappings":"6eAKA,SAASA,EAAcC,EAAQC,GAC3B,OAAOD,EAAOE,IAAI,IAAMD,GAAUE,GAAWC,OAAO,EAAGJ,EAAOK,OAAS,EAC3E,CACA,SAASC,GAAUC,SAAEA,EAAW,IAAKD,UAAWE,EAAcC,MAAEA,EAAKC,KAAEA,EAAO,cAK1E,MAAMC,EAAkBC,EAAcF,GAChCA,EAAKR,IAAIW,GACTA,EAA2BH,GAK3BI,EAAQ,CACVC,MAAM,EACNC,MAAOR,EAAe,IAKpBS,EAAgBC,EAGtBT,GAASA,EAAMJ,SAAWG,EAAeH,OACnCI,EACAU,EAAcX,GAAiBD,GAC/Ba,EAAoBC,EAAYJ,EAAeT,EAAgB,CACjEE,KAAMY,MAAMC,QAAQZ,GACdA,EACAZ,EAAcS,EAAgBG,KAExC,MAAO,CACHa,mBAAoBjB,EACpBkB,KAAOC,IACHZ,EAAME,MAAQI,EAAkBM,GAChCZ,EAAMC,KAAOW,GAAKnB,EACXO,GAGnB"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/spring.mjs.js

@@ -1,2 +0,0 @@
-import{generateLinearEasing as t}from"../waapi/utils/linear.mjs.js";import{calcGeneratorDuration as s,maxGeneratorDuration as e}from"./utils/calc-duration.mjs.js";import{createGeneratorEasing as n}from"./utils/create-generator-easing.mjs.js";import{millisecondsToSeconds as a,secondsToMilliseconds as o}from"../../../../../motion-utils/dist/es/time-conversion.mjs.js";import{clamp as r}from"../../../../../motion-utils/dist/es/clamp.mjs.js";import{warning as i}from"../../../../../motion-utils/dist/es/errors.mjs.js";const u=100,c=10,l=1,m=0,h=800,f=.3,M=.3,p={granular:.01,default:2},d={granular:.005,default:.5},v=.01,g=10,y=.05,x=1;function j(t,s){return t*Math.sqrt(1-s*s)}const b=.001;const D=["duration","bounce"],q=["stiffness","damping","mass"];function k(t,s){return s.some(s=>void 0!==t[s])}function w(t){let s={velocity:m,stiffness:u,damping:c,mass:l,isResolvedFromDuration:!1,...t};if(!k(t,q)&&k(t,D))if(s.velocity=0,t.visualDuration){const e=t.visualDuration,n=2*Math.PI/(1.2*e),a=n*n,o=2*r(.05,1,1-(t.bounce||0))*Math.sqrt(a);s={...s,mass:l,stiffness:a,damping:o}}else{const e=function({duration:t=h,bounce:s=f,velocity:e=m,mass:n=l}){let M,p;i(t<=o(g),"Spring duration must be 10 seconds or less","spring-duration-limit");let d=1-s;d=r(y,x,d),t=r(v,g,a(t)),d<1?(M=s=>{const n=s*d,a=n*t,o=n-e,r=j(s,d),i=Math.exp(-a);return b-o/r*i},p=s=>{const n=s*d*t,a=n*e+e,o=Math.pow(d,2)*Math.pow(s,2)*t,r=Math.exp(-n),i=j(Math.pow(s,2),d);return(-M(s)+b>0?-1:1)*((a-o)*r)/i}):(M=s=>Math.exp(-s*t)*((s-e)*t+1)-.001,p=s=>Math.exp(-s*t)*(t*t*(e-s)));const D=function(t,s,e){let n=e;for(let e=1;e<12;e++)n-=t(n)/s(n);return n}(M,p,5/t);if(t=o(t),isNaN(D))return{stiffness:u,damping:c,duration:t};{const s=Math.pow(D,2)*n;return{stiffness:s,damping:2*d*Math.sqrt(n*s),duration:t}}}({...t,velocity:0});s={...s,...e,mass:l},s.isResolvedFromDuration=!0}return s}function F(n=M,r=f){const i="object"!=typeof n?{visualDuration:n,keyframes:[0,1],bounce:r}:n;let{restSpeed:u,restDelta:c}=i;const l=i.keyframes[0],m=i.keyframes[i.keyframes.length-1],h={done:!1,value:l},{stiffness:v,damping:g,mass:y,duration:x,velocity:b,isResolvedFromDuration:D}=w({...i,velocity:-a(i.velocity||0)}),q=b||0,k=g/(2*Math.sqrt(v*y)),F=m-l,R=a(Math.sqrt(v/y)),S=Math.abs(F)<5;let N,T,I,O,P,z;if(u||(u=S?p.granular:p.default),c||(c=S?d.granular:d.default),k<1)I=j(R,k),O=(q+k*R*F)/I,N=t=>{const s=Math.exp(-k*R*t);return m-s*(O*Math.sin(I*t)+F*Math.cos(I*t))},P=k*R*O+F*I,z=k*R*F-O*I,T=t=>Math.exp(-k*R*t)*(P*Math.sin(I*t)+z*Math.cos(I*t));else if(1===k){N=t=>m-Math.exp(-R*t)*(F+(q+R*F)*t);const t=q+R*F;T=s=>Math.exp(-R*s)*(R*t*s-q)}else{const t=R*Math.sqrt(k*k-1);N=s=>{const e=Math.exp(-k*R*s),n=Math.min(t*s,300);return m-e*((q+k*R*F)*Math.sinh(n)+t*F*Math.cosh(n))/t};const s=(q+k*R*F)/t,e=k*R*s-F*t,n=k*R*F-s*t;T=s=>{const a=Math.exp(-k*R*s),o=Math.min(t*s,300);return a*(e*Math.sinh(o)+n*Math.cosh(o))}}const A={calculatedDuration:D&&x||null,velocity:t=>o(T(t)),next:t=>{if(!D&&k<1){const s=Math.exp(-k*R*t),e=Math.sin(I*t),n=Math.cos(I*t),a=m-s*(O*e+F*n),r=o(s*(P*e+z*n));return h.done=Math.abs(r)<=u&&Math.abs(m-a)<=c,h.value=h.done?m:a,h}const s=N(t);if(D)h.done=t>=x;else{const e=o(T(t));h.done=Math.abs(e)<=u&&Math.abs(m-s)<=c}return h.value=h.done?m:s,h},toString:()=>{const n=Math.min(s(A),e),a=t(t=>A.next(n*t).value,n,30);return n+"ms "+a},toTransition:()=>{}};return A}F.applyToOptions=t=>{const s=n(t,100,F);return t.ease=s.ease,t.duration=o(s.duration),t.type="keyframes",t};export{F as spring};
-//# sourceMappingURL=spring.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/spring.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"spring.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/generators/spring.mjs"],"sourcesContent":["import { millisecondsToSeconds, clamp, secondsToMilliseconds, warning } from 'motion-utils';\nimport { generateLinearEasing } from '../waapi/utils/linear.mjs';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './utils/calc-duration.mjs';\nimport { createGeneratorEasing } from './utils/create-generator-easing.mjs';\n\nconst springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\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}\n/**\n * This is ported from the Framer implementation of duration-based spring resolution.\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\", \"spring-duration-limit\");\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 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        // Time-defined springs should ignore inherited velocity.\n        // Velocity from interrupted animations can cause findSpring()\n        // to compute wildly different spring parameters, leading to\n        // massive oscillation on small-range animations.\n        springOptions.velocity = 0;\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, velocity: 0 });\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    let resolveVelocity;\n    // Underdamped coefficients, hoisted for use in the inlined next() hot path\n    let angularFreq;\n    let A;\n    let sinCoeff;\n    let cosCoeff;\n    if (dampingRatio < 1) {\n        angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        A =\n            (initialVelocity +\n                dampingRatio * undampedAngularFreq * initialDelta) /\n                angularFreq;\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (A * Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n        // Analytical derivative of underdamped spring (px/ms)\n        sinCoeff =\n            dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;\n        cosCoeff =\n            dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return envelope *\n                (sinCoeff * Math.sin(angularFreq * t) +\n                    cosCoeff * 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        // Analytical derivative of critically damped spring (px/ms)\n        const C = initialVelocity + undampedAngularFreq * initialDelta;\n        resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) *\n            (undampedAngularFreq * C * t - initialVelocity);\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        // Analytical derivative of overdamped spring (px/ms)\n        const P = (initialVelocity +\n            dampingRatio * undampedAngularFreq * initialDelta) /\n            dampedAngularFreq;\n        const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;\n        const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return envelope *\n                (sinhCoeff * Math.sinh(freqForT) +\n                    coshCoeff * Math.cosh(freqForT));\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        velocity: (t) => secondsToMilliseconds(resolveVelocity(t)),\n        next: (t) => {\n            /**\n             * For underdamped physics springs we need both position and\n             * velocity each tick. Compute shared trig values once to avoid\n             * duplicate Math.exp/sin/cos calls on the hot path.\n             */\n            if (!isResolvedFromDuration && dampingRatio < 1) {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const sin = Math.sin(angularFreq * t);\n                const cos = Math.cos(angularFreq * t);\n                const current = target -\n                    envelope *\n                        (A * sin + initialDelta * cos);\n                const currentVelocity = secondsToMilliseconds(envelope *\n                    (sinCoeff * sin + cosCoeff * cos));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\n                state.value = state.done ? target : current;\n                return state;\n            }\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                const currentVelocity = secondsToMilliseconds(resolveVelocity(t));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\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        toTransition: () => { },\n    };\n    return generator;\n}\nspring.applyToOptions = (options) => {\n    const generatorOptions = createGeneratorEasing(options, 100, spring);\n    options.ease = generatorOptions.ease;\n    options.duration = secondsToMilliseconds(generatorOptions.duration);\n    options.type = \"keyframes\";\n    return options;\n};\n\nexport { spring };\n//# sourceMappingURL=spring.mjs.map\n"],"names":["springDefaults","granular","default","calcAngularFreq","undampedFreq","dampingRatio","Math","sqrt","safeMin","durationKeys","physicsKeys","isSpringType","options","keys","some","key","undefined","getSpringOptions","springOptions","velocity","stiffness","damping","mass","isResolvedFromDuration","visualDuration","root","PI","clamp","bounce","derived","duration","envelope","derivative","warning","secondsToMilliseconds","millisecondsToSeconds","exponentialDecay","delta","a","b","c","exp","d","e","pow","f","g","initialGuess","result","i","approximateRoot","isNaN","findSpring","spring","optionsOrVisualDuration","keyframes","restSpeed","restDelta","origin","target","length","state","done","value","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","abs","resolveSpring","resolveVelocity","angularFreq","A","sinCoeff","cosCoeff","t","sin","cos","C","dampedAngularFreq","freqForT","min","sinh","cosh","P","sinhCoeff","coshCoeff","generator","calculatedDuration","next","current","currentVelocity","toString","calcGeneratorDuration","maxGeneratorDuration","easing","generateLinearEasing","progress","toTransition","applyToOptions","generatorOptions","createGeneratorEasing","ease","type"],"mappings":"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"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs.js

@@ -1,2 +0,0 @@
-const e=2e4;function t(t){let n=0;let o=t.next(n);for(;!o.done&&n<e;)n+=50,o=t.next(n);return n>=e?1/0:n}export{t as calcGeneratorDuration,e as maxGeneratorDuration};
-//# sourceMappingURL=calc-duration.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"calc-duration.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs"],"sourcesContent":["/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n//# sourceMappingURL=calc-duration.mjs.map\n"],"names":["maxGeneratorDuration","calcGeneratorDuration","generator","duration","state","next","done","Infinity"],"mappings":"AAIK,MAACA,EAAuB,IAC7B,SAASC,EAAsBC,GAC3B,IAAIC,EAAW,EAEf,IAAIC,EAAQF,EAAUG,KAAKF,GAC3B,MAAQC,EAAME,MAAQH,EAAWH,GAC7BG,GAHa,GAIbC,EAAQF,EAAUG,KAAKF,GAE3B,OAAOA,GAAYH,EAAuBO,IAAWJ,CACzD"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs.js

@@ -1,2 +0,0 @@
-import{calcGeneratorDuration as t,maxGeneratorDuration as e}from"./calc-duration.mjs.js";import{millisecondsToSeconds as o}from"../../../../../../motion-utils/dist/es/time-conversion.mjs.js";function r(r,s=100,i){const m=i({...r,keyframes:[0,s]}),n=Math.min(t(m),e);return{type:"keyframes",ease:t=>m.next(n*t).value/s,duration:o(n)}}export{r as createGeneratorEasing};
-//# sourceMappingURL=create-generator-easing.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-generator-easing.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs"],"sourcesContent":["import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n//# sourceMappingURL=create-generator-easing.mjs.map\n"],"names":["createGeneratorEasing","options","scale","createGenerator","generator","keyframes","duration","Math","min","calcGeneratorDuration","maxGeneratorDuration","type","ease","progress","next","value","millisecondsToSeconds"],"mappings":"+LAMA,SAASA,EAAsBC,EAASC,EAAQ,IAAKC,GACjD,MAAMC,EAAYD,EAAgB,IAAKF,EAASI,UAAW,CAAC,EAAGH,KACzDI,EAAWC,KAAKC,IAAIC,EAAsBL,GAAYM,GAC5D,MAAO,CACHC,KAAM,YACNC,KAAOC,GACIT,EAAUU,KAAKR,EAAWO,GAAUE,MAAQb,EAEvDI,SAAUU,EAAsBV,GAExC"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs.js

@@ -1,2 +0,0 @@
-function n(n){return"function"==typeof n&&"applyToOptions"in n}export{n as isGenerator};
-//# sourceMappingURL=is-generator.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-generator.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs"],"sourcesContent":["function isGenerator(type) {\n    return typeof type === \"function\" && \"applyToOptions\" in type;\n}\n\nexport { isGenerator };\n//# sourceMappingURL=is-generator.mjs.map\n"],"names":["isGenerator","type"],"mappings":"AAAA,SAASA,EAAYC,GACjB,MAAuB,mBAATA,GAAuB,mBAAoBA,CAC7D"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs.js

@@ -1,2 +0,0 @@
-import{velocityPerSecond as t}from"../../../../../../motion-utils/dist/es/velocity-per-second.mjs.js";function o(o,s,e){const i=Math.max(s-5,0);return t(e-o(i),s-i)}export{o as getGeneratorVelocity};
-//# sourceMappingURL=velocity.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"velocity.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs"],"sourcesContent":["import { velocityPerSecond } from 'motion-utils';\n\nconst velocitySampleDuration = 5; // ms\nfunction getGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { getGeneratorVelocity };\n//# sourceMappingURL=velocity.mjs.map\n"],"names":["getGeneratorVelocity","resolveValue","t","current","prevT","Math","max","velocityPerSecond"],"mappings":"sGAGA,SAASA,EAAqBC,EAAcC,EAAGC,GAC3C,MAAMC,EAAQC,KAAKC,IAAIJ,EAFI,EAEwB,GACnD,OAAOK,EAAkBJ,EAAUF,EAAaG,GAAQF,EAAIE,EAChE"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs.js

@@ -1,2 +0,0 @@
-import{AsyncMotionValueAnimation as e}from"../AsyncMotionValueAnimation.mjs.js";import{JSAnimation as t}from"../JSAnimation.mjs.js";import{getValueTransition as o}from"../utils/get-value-transition.mjs.js";import{makeAnimationInstant as i}from"../utils/make-animation-instant.mjs.js";import{getDefaultTransition as s}from"../utils/default-transitions.mjs.js";import{getFinalKeyframe as n}from"../keyframes/get-final.mjs.js";import{isTransitionDefined as a}from"../utils/is-transition-defined.mjs.js";import{frame as m}from"../../frameloop/frame.mjs.js";import{secondsToMilliseconds as r}from"../../../../../motion-utils/dist/es/time-conversion.mjs.js";import{MotionGlobalConfig as l}from"../../../../../motion-utils/dist/es/global-config.mjs.js";const p=(p,d,f,j={},y,u)=>c=>{const A=o(j,p)||{},k=A.delay||j.delay||0;let{elapsed:v=0}=j;v-=r(k);const g={keyframes:Array.isArray(f)?f:[null,f],ease:"easeOut",velocity:d.getVelocity(),...A,delay:-v,onUpdate:e=>{d.set(e),A.onUpdate&&A.onUpdate(e)},onComplete:()=>{c(),A.onComplete&&A.onComplete()},name:p,motionValue:d,element:u?void 0:y};a(A)||Object.assign(g,s(p,g)),g.duration&&(g.duration=r(g.duration)),g.repeatDelay&&(g.repeatDelay=r(g.repeatDelay)),void 0!==g.from&&(g.keyframes[0]=g.from);let C=!1;if((!1===g.type||0===g.duration&&!g.repeatDelay)&&(i(g),0===g.delay&&(C=!0)),(l.instantAnimations||l.skipAnimations||y?.shouldSkipAnimations||A.skipAnimations)&&(C=!0,i(g),g.delay=0),g.allowFlatten=!A.type&&!A.ease,C&&!u&&void 0!==d.get()){const e=n(g.keyframes,A);if(void 0!==e)return void m.update(()=>{g.onUpdate(e),g.onComplete()})}return A.isSync?new t(g):new e(g)};export{p as animateMotionValue};
-//# sourceMappingURL=motion-value.mjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"motion-value.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["import { secondsToMilliseconds, MotionGlobalConfig } from 'motion-utils';\nimport { AsyncMotionValueAnimation } from '../AsyncMotionValueAnimation.mjs';\nimport { JSAnimation } from '../JSAnimation.mjs';\nimport { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { makeAnimationInstant } from '../utils/make-animation-instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getFinalKeyframe } from '../keyframes/get-final.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\nimport { frame } from '../../frameloop/frame.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    const 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     * unique transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        Object.assign(options, getDefaultTransition(name, options));\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    options.duration && (options.duration = secondsToMilliseconds(options.duration));\n    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));\n    /**\n     * Support deprecated way to set initial value. Prefer keyframe syntax.\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        makeAnimationInstant(options);\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (MotionGlobalConfig.instantAnimations ||\n        MotionGlobalConfig.skipAnimations ||\n        element?.shouldSkipAnimations ||\n        valueTransition.skipAnimations) {\n        shouldSkip = true;\n        makeAnimationInstant(options);\n        options.delay = 0;\n    }\n    /**\n     * If the transition type or easing has been explicitly set by the user\n     * then we don't want to allow flattening the animation.\n     */\n    options.allowFlatten = !valueTransition.type && !valueTransition.ease;\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            return;\n        }\n    }\n    return valueTransition.isSync\n        ? new JSAnimation(options)\n        : new AsyncMotionValueAnimation(options);\n};\n\nexport { animateMotionValue };\n//# sourceMappingURL=motion-value.mjs.map\n"],"names":["animateMotionValue","name","value","target","transition","element","isHandoff","onComplete","valueTransition","getValueTransition","delay","elapsed","secondsToMilliseconds","options","keyframes","Array","isArray","ease","velocity","getVelocity","onUpdate","v","set","motionValue","undefined","isTransitionDefined","Object","assign","getDefaultTransition","duration","repeatDelay","from","shouldSkip","type","makeAnimationInstant","MotionGlobalConfig","instantAnimations","skipAnimations","shouldSkipAnimations","allowFlatten","get","finalKeyframe","getFinalKeyframe","frame","update","isSync","JSAnimation","AsyncMotionValueAnimation"],"mappings":"0uBAUK,MAACA,EAAqB,CAACC,EAAMC,EAAOC,EAAQC,EAAa,CAAA,EAAIC,EAASC,IAAeC,IACtF,MAAMC,EAAkBC,EAAmBL,EAAYH,IAAS,CAAA,EAM1DS,EAAQF,EAAgBE,OAASN,EAAWM,OAAS,EAK3D,IAAIC,QAAEA,EAAU,GAAMP,EACtBO,GAAoBC,EAAsBF,GAC1C,MAAMG,EAAU,CACZC,UAAWC,MAAMC,QAAQb,GAAUA,EAAS,CAAC,KAAMA,GACnDc,KAAM,UACNC,SAAUhB,EAAMiB,iBACbX,EACHE,OAAQC,EACRS,SAAWC,IACPnB,EAAMoB,IAAID,GACVb,EAAgBY,UAAYZ,EAAgBY,SAASC,IAEzDd,WAAY,KACRA,IACAC,EAAgBD,YAAcC,EAAgBD,cAElDN,OACAsB,YAAarB,EACbG,QAASC,OAAYkB,EAAYnB,GAMhCoB,EAAoBjB,IACrBkB,OAAOC,OAAOd,EAASe,EAAqB3B,EAAMY,IAOtDA,EAAQgB,WAAahB,EAAQgB,SAAWjB,EAAsBC,EAAQgB,WACtEhB,EAAQiB,cAAgBjB,EAAQiB,YAAclB,EAAsBC,EAAQiB,mBAIvDN,IAAjBX,EAAQkB,OACRlB,EAAQC,UAAU,GAAKD,EAAQkB,MAEnC,IAAIC,GAAa,EA0BjB,KAzBqB,IAAjBnB,EAAQoB,MACc,IAArBpB,EAAQgB,WAAmBhB,EAAQiB,eACpCI,EAAqBrB,GACC,IAAlBA,EAAQH,QACRsB,GAAa,KAGjBG,EAAmBC,mBACnBD,EAAmBE,gBACnBhC,GAASiC,sBACT9B,EAAgB6B,kBAChBL,GAAa,EACbE,EAAqBrB,GACrBA,EAAQH,MAAQ,GAMpBG,EAAQ0B,cAAgB/B,EAAgByB,OAASzB,EAAgBS,KAM7De,IAAe1B,QAA6BkB,IAAhBtB,EAAMsC,MAAqB,CACvD,MAAMC,EAAgBC,EAAiB7B,EAAQC,UAAWN,GAC1D,QAAsBgB,IAAlBiB,EAKA,YAJAE,EAAMC,OAAO,KACT/B,EAAQO,SAASqB,GACjB5B,EAAQN,cAInB,CACD,OAAOC,EAAgBqC,OACjB,IAAIC,EAAYjC,GAChB,IAAIkC,EAA0BlC"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs.js

@@ -1,2 +0,0 @@
-import{getValueTransition as t}from"../utils/get-value-transition.mjs.js";import{resolveTransition as i}from"../utils/resolve-transition.mjs.js";import{positionalKeys as n}from"../../render/utils/keys-position.mjs.js";import{setTarget as o}from"../../render/utils/setters.mjs.js";import{addValueToWillChange as e}from"../../value/will-change/add-will-change.mjs.js";import{getOptimisedAppearId as s}from"../optimized-appear/get-appear-id.mjs.js";import{animateMotionValue as a}from"./motion-value.mjs.js";import{frame as r}from"../../frameloop/frame.mjs.js";function m({protectedKeys:t,needsAnimating:i},n){const o=t.hasOwnProperty(n)&&!0!==i[n];return i[n]=!1,o}function l(l,p,{delay:u=0,transitionOverride:c,type:d}={}){let{transition:f,transitionEnd:j,...g}=p;const y=l.getDefaultTransition();f=f?i(f,y):y;const h=f?.reduceMotion,v=f?.skipAnimations;c&&(f=c);const A=[],w=d&&l.animationState&&l.animationState.getState()[d],M=f?.path;M&&M.animateVisualElement(l,g,f,u,A);for(const i in g){const o=l.getValue(i,l.latestValues[i]??null),p=g[i];if(void 0===p||w&&m(w,i))continue;const c={delay:u,...t(f||{},i)};v&&(c.skipAnimations=!0);const d=o.get();if(void 0!==d&&!o.isAnimating()&&!Array.isArray(p)&&p===d&&!c.velocity){r.update(()=>o.set(p));continue}let j=!1;if(window.MotionHandoffAnimation){const t=s(l);if(t){const n=window.MotionHandoffAnimation(t,i,r);null!==n&&(c.startTime=n,j=!0)}}e(l,i);const y=h??l.shouldReduceMotion;o.start(a(i,o,p,y&&n.has(i)?{type:!1}:c,l,j));const M=o.animation;M&&A.push(M)}if(j){const t=()=>r.update(()=>{j&&o(l,j)});A.length?Promise.all(A).then(t):t()}return A}export{l as animateTarget};
-//# sourceMappingURL=visual-element-target.mjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element-target.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs"],"sourcesContent":["import { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { resolveTransition } from '../utils/resolve-transition.mjs';\nimport { positionalKeys } from '../../render/utils/keys-position.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { addValueToWillChange } from '../../value/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    let { transition, transitionEnd, ...target } = targetAndTransition;\n    const defaultTransition = visualElement.getDefaultTransition();\n    transition = transition\n        ? resolveTransition(transition, defaultTransition)\n        : defaultTransition;\n    const reduceMotion = transition?.reduceMotion;\n    const skipAnimations = transition?.skipAnimations;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    const path = transition?.path;\n    if (path) {\n        // path mutates `target` to claim x/y; loop below skips them.\n        path.animateVisualElement(visualElement, target, transition, delay, animations);\n    }\n    for (const key in target) {\n        const value = visualElement.getValue(key, visualElement.latestValues[key] ?? 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        if (skipAnimations)\n            valueTransition.skipAnimations = true;\n        /**\n         * If the value is already at the defined target, skip the animation.\n         * We still re-assert the value via frame.update to take precedence\n         * over any stale transitionEnd callbacks from previous animations.\n         */\n        const currentValue = value.get();\n        if (currentValue !== undefined &&\n            !value.isAnimating() &&\n            !Array.isArray(valueTarget) &&\n            valueTarget === currentValue &&\n            !valueTransition.velocity) {\n            frame.update(() => value.set(valueTarget));\n            continue;\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        const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;\n        value.start(animateMotionValue(key, value, valueTarget, 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        const applyTransitionEnd = () => frame.update(() => {\n            transitionEnd && setTarget(visualElement, transitionEnd);\n        });\n        if (animations.length) {\n            Promise.all(animations).then(applyTransitionEnd);\n        }\n        else {\n            applyTransitionEnd();\n        }\n    }\n    return animations;\n}\n\nexport { animateTarget };\n//# sourceMappingURL=visual-element-target.mjs.map\n"],"names":["shouldBlockAnimation","protectedKeys","needsAnimating","key","shouldBlock","hasOwnProperty","animateTarget","visualElement","targetAndTransition","delay","transitionOverride","type","transition","transitionEnd","target","defaultTransition","getDefaultTransition","resolveTransition","reduceMotion","skipAnimations","animations","animationTypeState","animationState","getState","path","animateVisualElement","value","getValue","latestValues","valueTarget","undefined","valueTransition","getValueTransition","currentValue","get","isAnimating","Array","isArray","velocity","frame","update","set","isHandoff","window","MotionHandoffAnimation","appearId","getOptimisedAppearId","startTime","addValueToWillChange","shouldReduceMotion","start","animateMotionValue","positionalKeys","has","animation","push","applyTransitionEnd","setTarget","length","Promise","all","then"],"mappings":"8iBAeA,SAASA,GAAqBC,cAAEA,EAAaC,eAAEA,GAAkBC,GAC7D,MAAMC,EAAcH,EAAcI,eAAeF,KAAgC,IAAxBD,EAAeC,GAExE,OADAD,EAAeC,IAAO,EACfC,CACX,CACA,SAASE,EAAcC,EAAeC,GAAqBC,MAAEA,EAAQ,EAACC,mBAAEA,EAAkBC,KAAEA,GAAS,IACjG,IAAIC,WAAEA,EAAUC,cAAEA,KAAkBC,GAAWN,EAC/C,MAAMO,EAAoBR,EAAcS,uBACxCJ,EAAaA,EACPK,EAAkBL,EAAYG,GAC9BA,EACN,MAAMG,EAAeN,GAAYM,aAC3BC,EAAiBP,GAAYO,eAC/BT,IACAE,EAAaF,GACjB,MAAMU,EAAa,GACbC,EAAqBV,GACvBJ,EAAce,gBACdf,EAAce,eAAeC,WAAWZ,GACtCa,EAAOZ,GAAYY,KACrBA,GAEAA,EAAKC,qBAAqBlB,EAAeO,EAAQF,EAAYH,EAAOW,GAExE,IAAK,MAAMjB,KAAOW,EAAQ,CACtB,MAAMY,EAAQnB,EAAcoB,SAASxB,EAAKI,EAAcqB,aAAazB,IAAQ,MACvE0B,EAAcf,EAAOX,GAC3B,QAAoB2B,IAAhBD,GACCR,GACGrB,EAAqBqB,EAAoBlB,GAC7C,SAEJ,MAAM4B,EAAkB,CACpBtB,WACGuB,EAAmBpB,GAAc,CAAE,EAAET,IAExCgB,IACAY,EAAgBZ,gBAAiB,GAMrC,MAAMc,EAAeP,EAAMQ,MAC3B,QAAqBJ,IAAjBG,IACCP,EAAMS,gBACNC,MAAMC,QAAQR,IACfA,IAAgBI,IACfF,EAAgBO,SAAU,CAC3BC,EAAMC,OAAO,IAAMd,EAAMe,IAAIZ,IAC7B,QACH,CAKD,IAAIa,GAAY,EAChB,GAAIC,OAAOC,uBAAwB,CAC/B,MAAMC,EAAWC,EAAqBvC,GACtC,GAAIsC,EAAU,CACV,MAAME,EAAYJ,OAAOC,uBAAuBC,EAAU1C,EAAKoC,GAC7C,OAAdQ,IACAhB,EAAgBgB,UAAYA,EAC5BL,GAAY,EAEnB,CACJ,CACDM,EAAqBzC,EAAeJ,GACpC,MAAM8C,EAAqB/B,GAAgBX,EAAc0C,mBACzDvB,EAAMwB,MAAMC,EAAmBhD,EAAKuB,EAAOG,EAAaoB,GAAsBG,EAAeC,IAAIlD,GAC3F,CAAEQ,MAAM,GACRoB,EAAiBxB,EAAemC,IACtC,MAAMY,EAAY5B,EAAM4B,UACpBA,GACAlC,EAAWmC,KAAKD,EAEvB,CACD,GAAIzC,EAAe,CACf,MAAM2C,EAAqB,IAAMjB,EAAMC,OAAO,KAC1C3B,GAAiB4C,EAAUlD,EAAeM,KAE1CO,EAAWsC,OACXC,QAAQC,IAAIxC,GAAYyC,KAAKL,GAG7BA,GAEP,CACD,OAAOpC,CACX"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs.js

@@ -1,2 +0,0 @@
-import{resolveVariant as e}from"../../render/utils/resolve-dynamic-variants.mjs.js";import{calcChildStagger as t}from"../utils/calc-child-stagger.mjs.js";import{animateTarget as r}from"./visual-element-target.mjs.js";function n(i,o,s={}){const a=e(i,o,"exit"===s.type?i.presenceContext?.custom:void 0);let{transition:l=i.getDefaultTransition()||{}}=a||{};s.transitionOverride&&(l=s.transitionOverride);const m=a?()=>Promise.all(r(i,a,s)):()=>Promise.resolve(),c=i.variantChildren&&i.variantChildren.size?(e=0)=>{const{delayChildren:r=0,staggerChildren:a,staggerDirection:m}=l;return function(e,r,i=0,o=0,s=0,a=1,l){const m=[];for(const c of e.variantChildren)c.notify("AnimationStart",r),m.push(n(c,r,{...l,delay:i+("function"==typeof o?0:o)+t(e.variantChildren,c,o,s,a)}).then(()=>c.notify("AnimationComplete",r)));return Promise.all(m)}(i,o,e,r,a,m,s)}:()=>Promise.resolve(),{when:d}=l;if(d){const[e,t]="beforeChildren"===d?[m,c]:[c,m];return e().then(()=>t())}return Promise.all([m(),c(s.delay)])}export{n as animateVariant};
-//# sourceMappingURL=visual-element-variant.mjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element-variant.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs"],"sourcesContent":["import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { calcChildStagger } from '../utils/calc-child-stagger.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? visualElement.presenceContext?.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, forwardDelay, delayChildren, 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, delay = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    for (const child of visualElement.variantChildren) {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delay +\n                (typeof delayChildren === \"function\" ? 0 : delayChildren) +\n                calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    }\n    return Promise.all(animations);\n}\n\nexport { animateVariant };\n//# sourceMappingURL=visual-element-variant.mjs.map\n"],"names":["animateVariant","visualElement","variant","options","resolved","resolveVariant","type","presenceContext","custom","undefined","transition","getDefaultTransition","transitionOverride","getAnimation","Promise","all","animateTarget","resolve","getChildAnimations","variantChildren","size","forwardDelay","delayChildren","staggerChildren","staggerDirection","delay","animations","child","notify","push","calcChildStagger","then","animateChildren","when","first","last"],"mappings":"yNAIA,SAASA,EAAeC,EAAeC,EAASC,EAAU,CAAA,GACtD,MAAMC,EAAWC,EAAeJ,EAAeC,EAA0B,SAAjBC,EAAQG,KAC1DL,EAAcM,iBAAiBC,YAC/BC,GACN,IAAIC,WAAEA,EAAaT,EAAcU,wBAA0B,IAAOP,GAAY,GAC1ED,EAAQS,qBACRF,EAAaP,EAAQS,oBAMzB,MAAMC,EAAeT,EACf,IAAMU,QAAQC,IAAIC,EAAcf,EAAeG,EAAUD,IACzD,IAAMW,QAAQG,UAKdC,EAAqBjB,EAAckB,iBAAmBlB,EAAckB,gBAAgBC,KACpF,CAACC,EAAe,KACd,MAAMC,cAAEA,EAAgB,EAACC,gBAAEA,EAAeC,iBAAEA,GAAsBd,EAClE,OAkBZ,SAAyBT,EAAeC,EAASuB,EAAQ,EAAGH,EAAgB,EAAGC,EAAkB,EAAGC,EAAmB,EAAGrB,GACtH,MAAMuB,EAAa,GACnB,IAAK,MAAMC,KAAS1B,EAAckB,gBAC9BQ,EAAMC,OAAO,iBAAkB1B,GAC/BwB,EAAWG,KAAK7B,EAAe2B,EAAOzB,EAAS,IACxCC,EACHsB,MAAOA,GACuB,mBAAlBH,EAA+B,EAAIA,GAC3CQ,EAAiB7B,EAAckB,gBAAiBQ,EAAOL,EAAeC,EAAiBC,KAC5FO,KAAK,IAAMJ,EAAMC,OAAO,oBAAqB1B,KAEpD,OAAOY,QAAQC,IAAIW,EACvB,CA9BmBM,CAAgB/B,EAAeC,EAASmB,EAAcC,EAAeC,EAAiBC,EAAkBrB,IAEjH,IAAMW,QAAQG,WAKdgB,KAAEA,GAASvB,EACjB,GAAIuB,EAAM,CACN,MAAOC,EAAOC,GAAiB,mBAATF,EAChB,CAACpB,EAAcK,GACf,CAACA,EAAoBL,GAC3B,OAAOqB,IAAQH,KAAK,IAAMI,IAC7B,CAEG,OAAOrB,QAAQC,IAAI,CAACF,IAAgBK,EAAmBf,EAAQsB,QAEvE"}

package/dist/node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs.js

@@ -1,2 +0,0 @@
-import{resolveVariant as t}from"../../render/utils/resolve-dynamic-variants.mjs.js";import{animateTarget as e}from"./visual-element-target.mjs.js";import{animateVariant as i}from"./visual-element-variant.mjs.js";function r(r,o,n={}){let s;if(r.notify("AnimationStart",o),Array.isArray(o)){const t=o.map(t=>i(r,t,n));s=Promise.all(t)}else if("string"==typeof o)s=i(r,o,n);else{const i="function"==typeof o?t(r,o,n.custom):o;s=Promise.all(e(r,i,n))}return s.then(()=>{r.notify("AnimationComplete",o)})}export{r as animateVisualElement};
-//# sourceMappingURL=visual-element.mjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element.mjs.js","sources":["../../../../../../../node_modules/motion-dom/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//# sourceMappingURL=visual-element.mjs.map\n"],"names":["animateVisualElement","visualElement","definition","options","animation","notify","Array","isArray","animations","map","variant","animateVariant","Promise","all","resolvedDefinition","resolveVariant","custom","animateTarget","then"],"mappings":"oNAIA,SAASA,EAAqBC,EAAeC,EAAYC,EAAU,CAAA,GAE/D,IAAIC,EACJ,GAFAH,EAAcI,OAAO,iBAAkBH,GAEnCI,MAAMC,QAAQL,GAAa,CAC3B,MAAMM,EAAaN,EAAWO,IAAKC,GAAYC,EAAeV,EAAeS,EAASP,IACtFC,EAAYQ,QAAQC,IAAIL,EAC3B,MACI,GAA0B,iBAAfN,EACZE,EAAYO,EAAeV,EAAeC,EAAYC,OAErD,CACD,MAAMW,EAA2C,mBAAfZ,EAC5Ba,EAAed,EAAeC,EAAYC,EAAQa,QAClDd,EACNE,EAAYQ,QAAQC,IAAII,EAAchB,EAAea,EAAoBX,GAC5E,CACD,OAAOC,EAAUc,KAAK,KAClBjB,EAAcI,OAAO,oBAAqBH,IAElD"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.mjs.js

@@ -1,2 +0,0 @@
-import{positionalKeys as e}from"../../render/utils/keys-position.mjs.js";import{findDimensionValueType as s}from"../../value/types/dimensions.mjs.js";import{getVariableValue as t}from"../utils/css-variables-conversion.mjs.js";import{isCSSVariableToken as r,containsCSSVariable as n}from"../utils/is-css-variable.mjs.js";import{KeyframeResolver as i}from"./KeyframesResolver.mjs.js";import{isNone as o}from"./utils/is-none.mjs.js";import{makeNoneKeyframesAnimatable as m}from"./utils/make-none-animatable.mjs.js";import{positionalValues as a,isNumOrPxType as l}from"./utils/unit-conversion.mjs.js";class u extends i{constructor(e,s,t,r,n){super(e,s,t,r,n,!0)}readKeyframes(){const{unresolvedKeyframes:i,element:o,name:m}=this;if(!o||!o.current)return;super.readKeyframes();for(let e=0;e<i.length;e++){let s=i[e];if("string"==typeof s&&(s=s.trim(),r(s))){const r=t(s,o.current);void 0!==r&&(i[e]=r),e===i.length-1&&(this.finalKeyframe=s)}}if(this.resolveNoneKeyframes(),!e.has(m)||2!==i.length)return;const[u,f]=i,h=s(u),d=s(f);if(n(u)!==n(f)&&a[m])this.needsMeasurement=!0;else if(h!==d)if(l(h)&&l(d))for(let e=0;e<i.length;e++){const s=i[e];"string"==typeof s&&(i[e]=parseFloat(s))}else a[m]&&(this.needsMeasurement=!0)}resolveNoneKeyframes(){const{unresolvedKeyframes:e,name:s}=this,t=[];for(let s=0;s<e.length;s++)(null===e[s]||o(e[s]))&&t.push(s);t.length&&m(e,t,s)}measureInitialState(){const{element:e,unresolvedKeyframes:s,name:t}=this;if(!e||!e.current)return;"height"===t&&(this.suspendedScrollY=window.pageYOffset),this.measuredOrigin=a[t](e.measureViewportBox(),window.getComputedStyle(e.current)),s[0]=this.measuredOrigin;const r=s[s.length-1];void 0!==r&&e.getValue(t,r).jump(r,!1)}measureEndState(){const{element:e,name:s,unresolvedKeyframes:t}=this;if(!e||!e.current)return;const r=e.getValue(s);r&&r.jump(this.measuredOrigin,!1);const n=t.length-1,i=t[n];t[n]=a[s](e.measureViewportBox(),window.getComputedStyle(e.current)),null!==i&&void 0===this.finalKeyframe&&(this.finalKeyframe=i),this.removedTransforms?.length&&this.removedTransforms.forEach(([s,t])=>{e.getValue(s).set(t)}),this.resolveNoneKeyframes()}}export{u as DOMKeyframesResolver};
-//# sourceMappingURL=DOMKeyframesResolver.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DOMKeyframesResolver.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.mjs"],"sourcesContent":["import { positionalKeys } from '../../render/utils/keys-position.mjs';\nimport { findDimensionValueType } from '../../value/types/dimensions.mjs';\nimport { getVariableValue } from '../utils/css-variables-conversion.mjs';\nimport { isCSSVariableToken, containsCSSVariable } from '../utils/is-css-variable.mjs';\nimport { KeyframeResolver } from './KeyframesResolver.mjs';\nimport { isNone } from './utils/is-none.mjs';\nimport { makeNoneKeyframesAnimatable } from './utils/make-none-animatable.mjs';\nimport { positionalValues, isNumOrPxType } from './utils/unit-conversion.mjs';\n\nclass DOMKeyframesResolver extends KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {\n        super(unresolvedKeyframes, onComplete, name, motionValue, element, true);\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, element, name } = this;\n        if (!element || !element.current)\n            return;\n        super.readKeyframes();\n        /**\n         * If any keyframe is a CSS variable, we need to find its value by sampling the element\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            let keyframe = unresolvedKeyframes[i];\n            if (typeof keyframe === \"string\") {\n                keyframe = keyframe.trim();\n                if (isCSSVariableToken(keyframe)) {\n                    const resolved = getVariableValue(keyframe, element.current);\n                    if (resolved !== undefined) {\n                        unresolvedKeyframes[i] = resolved;\n                    }\n                    if (i === unresolvedKeyframes.length - 1) {\n                        this.finalKeyframe = keyframe;\n                    }\n                }\n            }\n        }\n        /**\n         * Resolve \"none\" values. We do this potentially twice - once before and once after measuring keyframes.\n         * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which\n         * have a far bigger performance impact.\n         */\n        this.resolveNoneKeyframes();\n        /**\n         * Check to see if unit type has changed. If so schedule jobs that will\n         * temporarily set styles to the destination keyframes.\n         * Skip if we have more than two keyframes or this isn't a positional value.\n         * TODO: We can throw if there are multiple keyframes and the value type changes.\n         */\n        if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {\n            return;\n        }\n        const [origin, target] = unresolvedKeyframes;\n        const originType = findDimensionValueType(origin);\n        const targetType = findDimensionValueType(target);\n        /**\n         * If one keyframe contains embedded CSS variables (e.g. in calc()) and the other\n         * doesn't, we need to measure to convert to pixels. This handles GitHub issue #3410.\n         */\n        const originHasVar = containsCSSVariable(origin);\n        const targetHasVar = containsCSSVariable(target);\n        if (originHasVar !== targetHasVar && positionalValues[name]) {\n            this.needsMeasurement = true;\n            return;\n        }\n        /**\n         * Either we don't recognise these value types or we can animate between them.\n         */\n        if (originType === targetType)\n            return;\n        /**\n         * If both values are numbers or pixels, we can animate between them by\n         * converting them to numbers.\n         */\n        if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {\n            for (let i = 0; i < unresolvedKeyframes.length; i++) {\n                const value = unresolvedKeyframes[i];\n                if (typeof value === \"string\") {\n                    unresolvedKeyframes[i] = parseFloat(value);\n                }\n            }\n        }\n        else if (positionalValues[name]) {\n            /**\n             * Else, the only way to resolve this is by measuring the element.\n             */\n            this.needsMeasurement = true;\n        }\n    }\n    resolveNoneKeyframes() {\n        const { unresolvedKeyframes, name } = this;\n        const noneKeyframeIndexes = [];\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (unresolvedKeyframes[i] === null ||\n                isNone(unresolvedKeyframes[i])) {\n                noneKeyframeIndexes.push(i);\n            }\n        }\n        if (noneKeyframeIndexes.length) {\n            makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);\n        }\n    }\n    measureInitialState() {\n        const { element, unresolvedKeyframes, name } = this;\n        if (!element || !element.current)\n            return;\n        if (name === \"height\") {\n            this.suspendedScrollY = window.pageYOffset;\n        }\n        this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        unresolvedKeyframes[0] = this.measuredOrigin;\n        // Set final key frame to measure after next render\n        const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n        if (measureKeyframe !== undefined) {\n            element.getValue(name, measureKeyframe).jump(measureKeyframe, false);\n        }\n    }\n    measureEndState() {\n        const { element, name, unresolvedKeyframes } = this;\n        if (!element || !element.current)\n            return;\n        const value = element.getValue(name);\n        value && value.jump(this.measuredOrigin, false);\n        const finalKeyframeIndex = unresolvedKeyframes.length - 1;\n        const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];\n        unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        if (finalKeyframe !== null && this.finalKeyframe === undefined) {\n            this.finalKeyframe = finalKeyframe;\n        }\n        // If we removed transform values, reapply them before the next render\n        if (this.removedTransforms?.length) {\n            this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {\n                element\n                    .getValue(unsetTransformName)\n                    .set(unsetTransformValue);\n            });\n        }\n        this.resolveNoneKeyframes();\n    }\n}\n\nexport { DOMKeyframesResolver };\n//# sourceMappingURL=DOMKeyframesResolver.mjs.map\n"],"names":["DOMKeyframesResolver","KeyframeResolver","constructor","unresolvedKeyframes","onComplete","name","motionValue","element","super","readKeyframes","this","current","i","length","keyframe","trim","isCSSVariableToken","resolved","getVariableValue","undefined","finalKeyframe","resolveNoneKeyframes","positionalKeys","has","origin","target","originType","findDimensionValueType","targetType","containsCSSVariable","positionalValues","needsMeasurement","isNumOrPxType","value","parseFloat","noneKeyframeIndexes","isNone","push","makeNoneKeyframesAnimatable","measureInitialState","suspendedScrollY","window","pageYOffset","measuredOrigin","measureViewportBox","getComputedStyle","measureKeyframe","getValue","jump","measureEndState","finalKeyframeIndex","removedTransforms","forEach","unsetTransformName","unsetTransformValue","set"],"mappings":"qlBASA,MAAMA,UAA6BC,EAC/B,WAAAC,CAAYC,EAAqBC,EAAYC,EAAMC,EAAaC,GAC5DC,MAAML,EAAqBC,EAAYC,EAAMC,EAAaC,GAAS,EACtE,CACD,aAAAE,GACI,MAAMN,oBAAEA,EAAmBI,QAAEA,EAAOF,KAAEA,GAASK,KAC/C,IAAKH,IAAYA,EAAQI,QACrB,OACJH,MAAMC,gBAIN,IAAK,IAAIG,EAAI,EAAGA,EAAIT,EAAoBU,OAAQD,IAAK,CACjD,IAAIE,EAAWX,EAAoBS,GACnC,GAAwB,iBAAbE,IACPA,EAAWA,EAASC,OAChBC,EAAmBF,IAAW,CAC9B,MAAMG,EAAWC,EAAiBJ,EAAUP,EAAQI,cACnCQ,IAAbF,IACAd,EAAoBS,GAAKK,GAEzBL,IAAMT,EAAoBU,OAAS,IACnCH,KAAKU,cAAgBN,EAE5B,CAER,CAaD,GAPAJ,KAAKW,wBAOAC,EAAeC,IAAIlB,IAAwC,IAA/BF,EAAoBU,OACjD,OAEJ,MAAOW,EAAQC,GAAUtB,EACnBuB,EAAaC,EAAuBH,GACpCI,EAAaD,EAAuBF,GAO1C,GAFqBI,EAAoBL,KACpBK,EAAoBJ,IACJK,EAAiBzB,GAClDK,KAAKqB,kBAAmB,OAM5B,GAAIL,IAAeE,EAMnB,GAAII,EAAcN,IAAeM,EAAcJ,GAC3C,IAAK,IAAIhB,EAAI,EAAGA,EAAIT,EAAoBU,OAAQD,IAAK,CACjD,MAAMqB,EAAQ9B,EAAoBS,GACb,iBAAVqB,IACP9B,EAAoBS,GAAKsB,WAAWD,GAE3C,MAEIH,EAAiBzB,KAItBK,KAAKqB,kBAAmB,EAE/B,CACD,oBAAAV,GACI,MAAMlB,oBAAEA,EAAmBE,KAAEA,GAASK,KAChCyB,EAAsB,GAC5B,IAAK,IAAIvB,EAAI,EAAGA,EAAIT,EAAoBU,OAAQD,KACb,OAA3BT,EAAoBS,IACpBwB,EAAOjC,EAAoBS,MAC3BuB,EAAoBE,KAAKzB,GAG7BuB,EAAoBtB,QACpByB,EAA4BnC,EAAqBgC,EAAqB9B,EAE7E,CACD,mBAAAkC,GACI,MAAMhC,QAAEA,EAAOJ,oBAAEA,EAAmBE,KAAEA,GAASK,KAC/C,IAAKH,IAAYA,EAAQI,QACrB,OACS,WAATN,IACAK,KAAK8B,iBAAmBC,OAAOC,aAEnChC,KAAKiC,eAAiBb,EAAiBzB,GAAME,EAAQqC,qBAAsBH,OAAOI,iBAAiBtC,EAAQI,UAC3GR,EAAoB,GAAKO,KAAKiC,eAE9B,MAAMG,EAAkB3C,EAAoBA,EAAoBU,OAAS,QACjDM,IAApB2B,GACAvC,EAAQwC,SAAS1C,EAAMyC,GAAiBE,KAAKF,GAAiB,EAErE,CACD,eAAAG,GACI,MAAM1C,QAAEA,EAAOF,KAAEA,EAAIF,oBAAEA,GAAwBO,KAC/C,IAAKH,IAAYA,EAAQI,QACrB,OACJ,MAAMsB,EAAQ1B,EAAQwC,SAAS1C,GAC/B4B,GAASA,EAAMe,KAAKtC,KAAKiC,gBAAgB,GACzC,MAAMO,EAAqB/C,EAAoBU,OAAS,EAClDO,EAAgBjB,EAAoB+C,GAC1C/C,EAAoB+C,GAAsBpB,EAAiBzB,GAAME,EAAQqC,qBAAsBH,OAAOI,iBAAiBtC,EAAQI,UACzG,OAAlBS,QAAiDD,IAAvBT,KAAKU,gBAC/BV,KAAKU,cAAgBA,GAGrBV,KAAKyC,mBAAmBtC,QACxBH,KAAKyC,kBAAkBC,QAAQ,EAAEC,EAAoBC,MACjD/C,EACKwC,SAASM,GACTE,IAAID,KAGjB5C,KAAKW,sBACR"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs.js

@@ -1,2 +0,0 @@
-import{fillWildcards as e}from"./utils/fill-wildcards.mjs.js";import{removeNonTranslationalTransform as s}from"./utils/unit-conversion.mjs.js";import{frame as t}from"../../frameloop/frame.mjs.js";const n=new Set;let i=!1,r=!1,a=!1;function o(){if(r){const e=Array.from(n).filter(e=>e.needsMeasurement),t=new Set(e.map(e=>e.element)),i=new Map;t.forEach(e=>{const t=s(e);t.length&&(i.set(e,t),e.render())}),e.forEach(e=>e.measureInitialState()),t.forEach(e=>{e.render();const s=i.get(e);s&&s.forEach(([s,t])=>{e.getValue(s)?.set(t)})}),e.forEach(e=>e.measureEndState()),e.forEach(e=>{void 0!==e.suspendedScrollY&&window.scrollTo(0,e.suspendedScrollY)})}r=!1,i=!1,n.forEach(e=>e.complete(a)),n.clear()}function l(){n.forEach(e=>{e.readKeyframes(),e.needsMeasurement&&(r=!0)})}function m(){a=!0,l(),o(),a=!1}class d{constructor(e,s,t,n,i,r=!1){this.state="pending",this.isAsync=!1,this.needsMeasurement=!1,this.unresolvedKeyframes=[...e],this.onComplete=s,this.name=t,this.motionValue=n,this.element=i,this.isAsync=r}scheduleResolve(){this.state="scheduled",this.isAsync?(n.add(this),i||(i=!0,t.read(l),t.resolveKeyframes(o))):(this.readKeyframes(),this.complete())}readKeyframes(){const{unresolvedKeyframes:s,name:t,element:n,motionValue:i}=this;if(null===s[0]){const e=i?.get(),r=s[s.length-1];if(void 0!==e)s[0]=e;else if(n&&t){const e=n.readValue(t,r);null!=e&&(s[0]=e)}void 0===s[0]&&(s[0]=r),i&&void 0===e&&i.set(s[0])}e(s)}setFinalKeyframe(){}measureInitialState(){}renderEndStyles(){}measureEndState(){}complete(e=!1){this.state="complete",this.onComplete(this.unresolvedKeyframes,this.finalKeyframe,e),n.delete(this)}cancel(){"scheduled"===this.state&&(n.delete(this),this.state="pending")}resume(){"pending"===this.state&&this.scheduleResolve()}}export{d as KeyframeResolver,m as flushKeyframeResolvers};
-//# sourceMappingURL=KeyframesResolver.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"KeyframesResolver.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs"],"sourcesContent":["import { fillWildcards } from './utils/fill-wildcards.mjs';\nimport { removeNonTranslationalTransform } from './utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nlet isForced = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    element.getValue(key)?.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete(isForced));\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    isForced = true;\n    readAllKeyframes();\n    measureAllKeyframes();\n    isForced = false;\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        this.state = \"pending\";\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.state = \"scheduled\";\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        // If initial keyframe is null we need to read it from the DOM\n        if (unresolvedKeyframes[0] === null) {\n            const currentValue = motionValue?.get();\n            // TODO: This doesn't work if the final keyframe is a wildcard\n            const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n            if (currentValue !== undefined) {\n                unresolvedKeyframes[0] = currentValue;\n            }\n            else if (element && name) {\n                const valueAsRead = element.readValue(name, finalKeyframe);\n                if (valueAsRead !== undefined && valueAsRead !== null) {\n                    unresolvedKeyframes[0] = valueAsRead;\n                }\n            }\n            if (unresolvedKeyframes[0] === undefined) {\n                unresolvedKeyframes[0] = finalKeyframe;\n            }\n            if (motionValue && currentValue === undefined) {\n                motionValue.set(unresolvedKeyframes[0]);\n            }\n        }\n        fillWildcards(unresolvedKeyframes);\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete(isForcedComplete = false) {\n        this.state = \"complete\";\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, isForcedComplete);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (this.state === \"scheduled\") {\n            toResolve.delete(this);\n            this.state = \"pending\";\n        }\n    }\n    resume() {\n        if (this.state === \"pending\")\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n//# sourceMappingURL=KeyframesResolver.mjs.map\n"],"names":["toResolve","Set","isScheduled","anyNeedsMeasurement","isForced","measureAllKeyframes","resolversToMeasure","Array","from","filter","resolver","needsMeasurement","elementsToMeasure","map","element","transformsToRestore","Map","forEach","removedTransforms","removeNonTranslationalTransform","length","set","render","measureInitialState","restore","get","key","value","getValue","measureEndState","undefined","suspendedScrollY","window","scrollTo","complete","clear","readAllKeyframes","readKeyframes","flushKeyframeResolvers","KeyframeResolver","constructor","unresolvedKeyframes","onComplete","name","motionValue","isAsync","this","state","scheduleResolve","add","frame","read","resolveKeyframes","currentValue","finalKeyframe","valueAsRead","readValue","fillWildcards","setFinalKeyframe","renderEndStyles","isForcedComplete","delete","cancel","resume"],"mappings":"oMAIA,MAAMA,EAAY,IAAIC,IACtB,IAAIC,GAAc,EACdC,GAAsB,EACtBC,GAAW,EACf,SAASC,IACL,GAAIF,EAAqB,CACrB,MAAMG,EAAqBC,MAAMC,KAAKR,GAAWS,OAAQC,GAAaA,EAASC,kBACzEC,EAAoB,IAAIX,IAAIK,EAAmBO,IAAKH,GAAaA,EAASI,UAC1EC,EAAsB,IAAIC,IAKhCJ,EAAkBK,QAASH,IACvB,MAAMI,EAAoBC,EAAgCL,GACrDI,EAAkBE,SAEvBL,EAAoBM,IAAIP,EAASI,GACjCJ,EAAQQ,YAGZhB,EAAmBW,QAASP,GAAaA,EAASa,uBAElDX,EAAkBK,QAASH,IACvBA,EAAQQ,SACR,MAAME,EAAUT,EAAoBU,IAAIX,GACpCU,GACAA,EAAQP,QAAQ,EAAES,EAAKC,MACnBb,EAAQc,SAASF,IAAML,IAAIM,OAKvCrB,EAAmBW,QAASP,GAAaA,EAASmB,mBAElDvB,EAAmBW,QAASP,SACUoB,IAA9BpB,EAASqB,kBACTC,OAAOC,SAAS,EAAGvB,EAASqB,mBAGvC,CACD5B,GAAsB,EACtBD,GAAc,EACdF,EAAUiB,QAASP,GAAaA,EAASwB,SAAS9B,IAClDJ,EAAUmC,OACd,CACA,SAASC,IACLpC,EAAUiB,QAASP,IACfA,EAAS2B,gBACL3B,EAASC,mBACTR,GAAsB,IAGlC,CACA,SAASmC,IACLlC,GAAW,EACXgC,IACA/B,IACAD,GAAW,CACf,CACA,MAAMmC,EACF,WAAAC,CAAYC,EAAqBC,EAAYC,EAAMC,EAAa9B,EAAS+B,GAAU,GAC/EC,KAAKC,MAAQ,UAMbD,KAAKD,SAAU,EAKfC,KAAKnC,kBAAmB,EACxBmC,KAAKL,oBAAsB,IAAIA,GAC/BK,KAAKJ,WAAaA,EAClBI,KAAKH,KAAOA,EACZG,KAAKF,YAAcA,EACnBE,KAAKhC,QAAUA,EACfgC,KAAKD,QAAUA,CAClB,CACD,eAAAG,GACIF,KAAKC,MAAQ,YACTD,KAAKD,SACL7C,EAAUiD,IAAIH,MACT5C,IACDA,GAAc,EACdgD,EAAMC,KAAKf,GACXc,EAAME,iBAAiB/C,MAI3ByC,KAAKT,gBACLS,KAAKZ,WAEZ,CACD,aAAAG,GACI,MAAMI,oBAAEA,EAAmBE,KAAEA,EAAI7B,QAAEA,EAAO8B,YAAEA,GAAgBE,KAE5D,GAA+B,OAA3BL,EAAoB,GAAa,CACjC,MAAMY,EAAeT,GAAanB,MAE5B6B,EAAgBb,EAAoBA,EAAoBrB,OAAS,GACvE,QAAqBU,IAAjBuB,EACAZ,EAAoB,GAAKY,OAExB,GAAIvC,GAAW6B,EAAM,CACtB,MAAMY,EAAczC,EAAQ0C,UAAUb,EAAMW,GACxCC,UACAd,EAAoB,GAAKc,EAEhC,MAC8BzB,IAA3BW,EAAoB,KACpBA,EAAoB,GAAKa,GAEzBV,QAAgCd,IAAjBuB,GACfT,EAAYvB,IAAIoB,EAAoB,GAE3C,CACDgB,EAAchB,EACjB,CACD,gBAAAiB,GAAsB,CACtB,mBAAAnC,GAAyB,CACzB,eAAAoC,GAAqB,CACrB,eAAA9B,GAAqB,CACrB,QAAAK,CAAS0B,GAAmB,GACxBd,KAAKC,MAAQ,WACbD,KAAKJ,WAAWI,KAAKL,oBAAqBK,KAAKQ,cAAeM,GAC9D5D,EAAU6D,OAAOf,KACpB,CACD,MAAAgB,GACuB,cAAfhB,KAAKC,QACL/C,EAAU6D,OAAOf,MACjBA,KAAKC,MAAQ,UAEpB,CACD,MAAAgB,GACuB,YAAfjB,KAAKC,OACLD,KAAKE,iBACZ"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/get-final.mjs.js

@@ -1,2 +0,0 @@
-const e=e=>null!==e;function o(o,{repeat:t,repeatType:n="loop"},l,p=1){const r=o.filter(e),c=p<0||t&&"loop"!==n&&t%2==1?0:r.length-1;return c&&void 0!==l?l:r[c]}export{o as getFinalKeyframe};
-//# sourceMappingURL=get-final.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/get-final.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-final.mjs.js","sources":["../../../../../../../node_modules/motion-dom/dist/es/animation/keyframes/get-final.mjs"],"sourcesContent":["const isNotNull = (value) => value !== null;\nfunction getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }, finalKeyframe, speed = 1) {\n    const resolvedKeyframes = keyframes.filter(isNotNull);\n    const useFirstKeyframe = speed < 0 || (repeat && repeatType !== \"loop\" && repeat % 2 === 1);\n    const index = useFirstKeyframe ? 0 : resolvedKeyframes.length - 1;\n    return !index || finalKeyframe === undefined\n        ? resolvedKeyframes[index]\n        : finalKeyframe;\n}\n\nexport { getFinalKeyframe };\n//# sourceMappingURL=get-final.mjs.map\n"],"names":["isNotNull","value","getFinalKeyframe","keyframes","repeat","repeatType","finalKeyframe","speed","resolvedKeyframes","filter","index","length","undefined"],"mappings":"AAAA,MAAMA,EAAaC,GAAoB,OAAVA,EAC7B,SAASC,EAAiBC,GAAWC,OAAEA,EAAMC,WAAEA,EAAa,QAAUC,EAAeC,EAAQ,GACzF,MAAMC,EAAoBL,EAAUM,OAAOT,GAErCU,EADmBH,EAAQ,GAAMH,GAAyB,SAAfC,GAAyBD,EAAS,GAAM,EACxD,EAAII,EAAkBG,OAAS,EAChE,OAAQD,QAA2BE,IAAlBN,EAEXA,EADAE,EAAkBE,EAE5B"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.mjs.js

@@ -1,2 +0,0 @@
-import{fillOffset as t}from"./fill.mjs.js";function n(n){const o=[0];return t(o,n.length-1),o}export{n as defaultOffset};
-//# sourceMappingURL=default.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.mjs"],"sourcesContent":["import { fillOffset } from './fill.mjs';\n\nfunction defaultOffset(arr) {\n    const offset = [0];\n    fillOffset(offset, arr.length - 1);\n    return offset;\n}\n\nexport { defaultOffset };\n//# sourceMappingURL=default.mjs.map\n"],"names":["defaultOffset","arr","offset","fillOffset","length"],"mappings":"2CAEA,SAASA,EAAcC,GACnB,MAAMC,EAAS,CAAC,GAEhB,OADAC,EAAWD,EAAQD,EAAIG,OAAS,GACzBF,CACX"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.mjs.js

@@ -1,2 +0,0 @@
-import{mixNumber as s}from"../../../utils/mix/number.mjs.js";import{progress as o}from"../../../../../../motion-utils/dist/es/progress.mjs.js";function t(t,m){const r=t[t.length-1];for(let i=1;i<=m;i++){const n=o(0,m,i);t.push(s(r,1,n))}}export{t as fillOffset};
-//# sourceMappingURL=fill.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fill.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.mjs"],"sourcesContent":["import { progress } from 'motion-utils';\nimport { mixNumber } from '../../../utils/mix/number.mjs';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mixNumber(min, 1, offsetProgress));\n    }\n}\n\nexport { fillOffset };\n//# sourceMappingURL=fill.mjs.map\n"],"names":["fillOffset","offset","remaining","min","length","i","offsetProgress","progress","push","mixNumber"],"mappings":"+IAGA,SAASA,EAAWC,EAAQC,GACxB,MAAMC,EAAMF,EAAOA,EAAOG,OAAS,GACnC,IAAK,IAAIC,EAAI,EAAGA,GAAKH,EAAWG,IAAK,CACjC,MAAMC,EAAiBC,EAAS,EAAGL,EAAWG,GAC9CJ,EAAOO,KAAKC,EAAUN,EAAK,EAAGG,GACjC,CACL"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.mjs.js

@@ -1,2 +0,0 @@
-function n(n,r){return n.map(n=>n*r)}export{n as convertOffsetToTimes};
-//# sourceMappingURL=time.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"time.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.mjs"],"sourcesContent":["function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n//# sourceMappingURL=time.mjs.map\n"],"names":["convertOffsetToTimes","offset","duration","map","o"],"mappings":"AAAA,SAASA,EAAqBC,EAAQC,GAClC,OAAOD,EAAOE,IAAKC,GAAMA,EAAIF,EACjC"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.mjs.js

@@ -1,2 +0,0 @@
-function t(t){for(let e=1;e<t.length;e++)t[e]??(t[e]=t[e-1])}export{t as fillWildcards};
-//# sourceMappingURL=fill-wildcards.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fill-wildcards.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.mjs"],"sourcesContent":["function fillWildcards(keyframes) {\n    for (let i = 1; i < keyframes.length; i++) {\n        keyframes[i] ?? (keyframes[i] = keyframes[i - 1]);\n    }\n}\n\nexport { fillWildcards };\n//# sourceMappingURL=fill-wildcards.mjs.map\n"],"names":["fillWildcards","keyframes","i","length"],"mappings":"AAAA,SAASA,EAAcC,GACnB,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAUE,OAAQD,IAClCD,EAAUC,KAAOD,EAAUC,GAAKD,EAAUC,EAAI,GAEtD"}

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/is-none.mjs.js

@@ -1,2 +0,0 @@
-import{isZeroValueString as n}from"../../../../../../motion-utils/dist/es/is-zero-value-string.mjs.js";function o(o){return"number"==typeof o?0===o:null===o||("none"===o||"0"===o||n(o))}export{o as isNone};
-//# sourceMappingURL=is-none.mjs.js.map