@burdenoff/microfe-mybodyshield 2026.1028.1 → 2026.1101.2

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

@@ -1,14 +1,14 @@
 import { invariant as e } from "../../../../motion-utils/dist/es/errors.js";
-import { noop as t } from "../../../../motion-utils/dist/es/noop.js";
-import { millisecondsToSeconds as n, secondsToMilliseconds as r } from "../../../../motion-utils/dist/es/time-conversion.js";
-import { getFinalKeyframe as i } from "./keyframes/get-final.js";
-import { WithPromise as a } from "./utils/WithPromise.js";
-import { setStyle as o } from "../render/dom/style-set.js";
-import { supportsScrollTimeline as s } from "../utils/supports/scroll-timeline.js";
+import { millisecondsToSeconds as t, secondsToMilliseconds as n } from "../../../../motion-utils/dist/es/time-conversion.js";
+import { noop as r } from "../../../../motion-utils/dist/es/noop.js";
+import { setStyle as i } from "../render/dom/style-set.js";
+import { supportsScrollTimeline as a } from "../utils/supports/scroll-timeline.js";
+import { getFinalKeyframe as o } from "./keyframes/get-final.js";
+import { WithPromise as s } from "./utils/WithPromise.js";
 import { startWaapiAnimation as c } from "./waapi/start-waapi-animation.js";
 import { applyGeneratorOptions as l } from "./waapi/utils/apply-generator.js";
-//#region node_modules/motion-dom/dist/es/animation/NativeAnimation.mjs
-var u = class extends a {
+// node_modules/motion-dom/dist/es/animation/NativeAnimation.mjs
+var u = class extends s {
 	constructor(t) {
 		if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !t) return;
 		let { element: n, name: r, keyframes: a, pseudoElement: s, allowFlatten: u = !1, finalKeyframe: d, onComplete: f } = t;
@@ -16,8 +16,8 @@ var u = class extends a {
 		let p = l(t);
 		this.animation = c(n, r, a, p, s), p.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
 			if (this.finishedTime = this.time, !s) {
-				let e = i(a, this.options, d, this.speed);
-				this.updateMotionValue && this.updateMotionValue(e), o(n, r, e), this.animation.cancel();
+				let e = o(a, this.options, d, this.speed);
+				this.updateMotionValue && this.updateMotionValue(e), i(n, r, e), this.animation.cancel();
 			}
 			f?.(), this.notifyFinished();
 		};
@@ -40,7 +40,7 @@ var u = class extends a {
 		if (this.isStopped) return;
 		this.isStopped = !0;
 		let { state: e } = this;
-		e === "idle" || e === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+		e !== "idle" && e !== "finished" && (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
 	}
 	commitStyles() {
 		let e = this.options?.element;
@@ -48,18 +48,18 @@ var u = class extends a {
 	}
 	get duration() {
 		let e = this.animation.effect?.getComputedTiming?.().duration || 0;
-		return n(Number(e));
+		return t(Number(e));
 	}
 	get iterationDuration() {
 		let { delay: e = 0 } = this.options || {};
-		return this.duration + n(e);
+		return this.duration + t(e);
 	}
 	get time() {
-		return n(Number(this.animation.currentTime) || 0);
+		return t(Number(this.animation.currentTime) || 0);
 	}
 	set time(e) {
 		let t = this.finishedTime !== null;
-		this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = r(e), t && this.animation.pause();
+		this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = n(e), t && this.animation.pause();
 	}
 	get speed() {
 		return this.animation.playbackRate;
@@ -76,11 +76,10 @@ var u = class extends a {
 	set startTime(e) {
 		this.manualStartTime = this.animation.startTime = e;
 	}
-	attachTimeline({ timeline: e, rangeStart: n, rangeEnd: r, observe: i }) {
-		return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, e && s() ? (this.animation.timeline = e, n && (this.animation.rangeStart = n), r && (this.animation.rangeEnd = r), t) : i(this);
+	attachTimeline({ timeline: e, rangeStart: t, rangeEnd: n, observe: i }) {
+		return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, e && a() ? (this.animation.timeline = e, t && (this.animation.rangeStart = t), n && (this.animation.rangeEnd = n), r) : i(this);
 	}
 };
-//#endregion
 export { u as NativeAnimation };
 
 //# sourceMappingURL=NativeAnimation.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"NativeAnimation.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"NativeAnimation.js","names":["NativeAnimation","WithPromise","options","pseudoElement","allowFlatten","invariant","transition","applyGeneratorOptions","startWaapiAnimation","element","name","keyframes","keyframe","getFinalKeyframe","finalKeyframe","setStyle","onComplete","state","duration","millisecondsToSeconds","delay","wasFinished","secondsToMilliseconds","newTime","newSpeed","newStartTime","timeline","supportsScrollTimeline","rangeStart","rangeEnd","noop","observe"],"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"],"ignoreList":[0],"mappings":";;;;;;;;;;AAWA,IAAMA,IAAN,cAA8BC,EAAY;CACtC,YAAY,GAAS;EAUjB,IATA,MAAM,GACN,KAAK,eAAe,MACpB,KAAK,YAAY,IAMjB,KAAK,kBAAkB,MACnB,CAACC,GACD;EACJ,IAAM,EAAE,YAAS,SAAM,cAAW,kBAAe,kBAAe,IAAO,kBAAe,kBAAgBA;EAItG,AAHA,KAAK,kBAAkB,EAAQC,GAC/B,KAAK,eAAeC,GACpB,KAAK,UAAUF,GACfG,EAAU,OAAOH,EAAQ,QAAS,UAAU,wDAAsD,aAAa;EAC/G,IAAMI,IAAaC,EAAsBL,CAAO;EAKhD,AAJA,KAAK,YAAYM,EAAoBC,GAASC,GAAMC,GAAWL,GAAYH,CAAa,GACpFG,EAAW,aAAa,MACxB,KAAK,UAAU,MAAM,GAEzB,KAAK,UAAU,iBAAiB;GAE5B,IADA,KAAK,eAAe,KAAK,MACrB,CAACH,GAAe;IAChB,IAAMS,IAAWC,EAAiBF,GAAW,KAAK,SAASG,GAAe,KAAK,KAAK;IAYpF,AAXI,KAAK,qBACL,KAAK,kBAAkBF,CAAQ,GASnCG,EAASN,GAASC,GAAME,CAAQ,GAChC,KAAK,UAAU,OAAO;GAC1B;GAEA,AADAI,IAAa,GACb,KAAK,eAAe;EACxB;CACJ;CACA,OAAO;EACH,AAAI,KAAK,cAET,KAAK,kBAAkB,MACvB,KAAK,UAAU,KAAK,GAChB,KAAK,UAAU,cACf,KAAK,eAAe;CAE5B;CACA,QAAQ;EACJ,KAAK,UAAU,MAAM;CACzB;CACA,WAAW;EACP,KAAK,UAAU,SAAS;CAC5B;CACA,SAAS;EACL,IAAI;GACA,KAAK,UAAU,OAAO;EAC1B,QACU,CAAE;CAChB;CACA,OAAO;EACH,IAAI,KAAK,WACL;EACJ,KAAK,YAAY;EACjB,IAAM,EAAE,aAAU;EAClB,AAAIC,MAAU,UAAUA,MAAU,eAG9B,KAAK,oBACL,KAAK,kBAAkB,IAGvB,KAAK,aAAa,GAEjB,KAAK,mBACN,KAAK,OAAO;CACpB;CAaA,eAAe;EACX,IAAMR,IAAU,KAAK,SAAS;EAC9B,AAAI,CAAC,KAAK,mBAAmBA,GAAS,eAClC,KAAK,UAAU,eAAe;CAEtC;CACA,IAAI,WAAW;EACX,IAAMS,IAAW,KAAK,UAAU,QAAQ,oBAAoB,CAAC,CAAC,YAAY;EAC1E,OAAOC,EAAsB,OAAOD,CAAQ,CAAC;CACjD;CACA,IAAI,oBAAoB;EACpB,IAAM,EAAE,WAAQ,MAAM,KAAK,WAAW,CAAC;EACvC,OAAO,KAAK,WAAWC,EAAsBC,CAAK;CACtD;CACA,IAAI,OAAO;EACP,OAAOD,EAAsB,OAAO,KAAK,UAAU,WAAW,KAAK,CAAC;CACxE;CACA,IAAI,KAAK,GAAS;EACd,IAAME,IAAc,KAAK,iBAAiB;EAI1C,AAHA,KAAK,kBAAkB,MACvB,KAAK,eAAe,MACpB,KAAK,UAAU,cAAcC,EAAsBC,CAAO,GACtDF,KACA,KAAK,UAAU,MAAM;CAE7B;CAKA,IAAI,QAAQ;EACR,OAAO,KAAK,UAAU;CAC1B;CACA,IAAI,MAAM,GAAU;EAIhB,AAFIG,IAAW,MACX,KAAK,eAAe,OACxB,KAAK,UAAU,eAAeA;CAClC;CACA,IAAI,QAAQ;EACR,OAAO,KAAK,iBAAiB,OAEvB,KAAK,UAAU,YADf;CAEV;CACA,IAAI,YAAY;EACZ,OAAO,KAAK,mBAAmB,OAAO,KAAK,UAAU,SAAS;CAClE;CACA,IAAI,UAAU,GAAc;EACxB,KAAK,kBAAkB,KAAK,UAAU,YAAYC;CACtD;CAIA,eAAe,EAAE,aAAU,eAAY,aAAU,cAAY;EAcrD,OAbA,KAAK,gBACL,KAAK,UAAU,QAAQ,aAAa,EAAE,QAAQ,SAAS,CAAC,GAE5D,KAAK,UAAU,WAAW,MACtBC,KAAYC,EAAuB,KACnC,KAAK,UAAU,WAAWD,GACtBE,MACA,KAAK,UAAU,aAAaA,IAC5BC,MACA,KAAK,UAAU,WAAWA,IACvBC,KAGAC,EAAQ,IAAI;CAE3B;AACJ"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"NativeAnimationExtended.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAaA,IAAM,IAAc,IACd,IAAN,cAAsC,EAAgB;CAClD,YAAY,GAAS;AA4BjB,EAlBA,EAAoB,EAAQ,EAQ5B,EAAsB,EAAQ,EAC9B,MAAM,EAAQ,EAMV,EAAQ,cAAc,KAAA,KAAa,EAAQ,aAAa,OACxD,KAAK,YAAY,EAAQ,YAE7B,KAAK,UAAU;;CAUnB,kBAAkB,GAAO;EACrB,IAAM,EAAE,gBAAa,aAAU,eAAY,YAAS,GAAG,MAAY,KAAK;AACxE,MAAI,CAAC,EACD;AACJ,MAAI,MAAU,KAAA,GAAW;AACrB,KAAY,IAAI,EAAM;AACtB;;EAEJ,IAAM,IAAkB,IAAI,EAAY;GACpC,GAAG;GACH,UAAU;GACb,CAAC,EAMI,IAAa,KAAK,IAAI,GAAa,EAAK,KAAK,GAAG,KAAK,UAAU,EAC/D,IAAQ,EAAM,GAAG,GAAa,IAAa,EAAY,EACvD,IAAU,EAAgB,OAAO,EAAW,CAAC,OAM7C,EAAE,YAAS,KAAK;AAItB,EAHI,KAAW,KACX,EAAS,GAAS,GAAM,EAAQ,EACpC,EAAY,gBAAgB,EAAgB,OAAO,KAAK,IAAI,GAAG,IAAa,EAAM,CAAC,CAAC,OAAO,GAAS,EAAM,EAC1G,EAAgB,MAAM"}
+{"version":3,"file":"NativeAnimationExtended.js","names":["sampleDelta","NativeAnimationExtended","NativeAnimation","replaceStringEasing","options","replaceTransitionType","motionValue","value","sampleAnimation","JSAnimation","sampleTime","time","delta","clamp","current","element","name","setStyle"],"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"],"ignoreList":[0],"mappings":";;;;;;;;AAaA,IAAMA,IAAc,IACdC,IAAN,cAAsCC,EAAgB;CAClD,YAAY,GAAS;EA4BjB,AAlBAC,EAAoBC,CAAO,GAQ3BC,EAAsBD,CAAO,GAC7B,MAAMA,CAAO,GAMTA,EAAQ,cAAc,KAAA,KAAaA,EAAQ,aAAa,OACxD,KAAK,YAAYA,EAAQ,YAE7B,KAAK,UAAUA;CACnB;CASA,kBAAkB,GAAO;EACrB,IAAM,EAAE,gBAAa,aAAU,eAAY,YAAS,GAAGA,MAAY,KAAK;EACxE,IAAI,CAACE,GACD;EACJ,IAAIC,MAAU,KAAA,GAAW;GACrB,EAAY,IAAIA,CAAK;GACrB;EACJ;EACA,IAAMC,IAAkB,IAAIC,EAAY;GACpC,GAAGL;GACH,UAAU;EACd,CAAC,GAMKM,IAAa,KAAK,IAAIV,GAAaW,EAAK,IAAI,IAAI,KAAK,SAAS,GAC9DC,IAAQC,EAAM,GAAGb,GAAaU,IAAaV,CAAW,GACtDc,IAAUN,EAAgB,OAAOE,CAAU,CAAC,CAAC,OAM7C,EAAE,YAAS,KAAK;EAItB,AAHIK,KAAWC,KACXC,EAASF,GAASC,GAAMF,CAAO,GACnCR,EAAY,gBAAgBE,EAAgB,OAAO,KAAK,IAAI,GAAGE,IAAaE,CAAK,CAAC,CAAC,CAAC,OAAOE,GAASF,CAAK,GACzGJ,EAAgB,KAAK;CACzB;AACJ"}

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

@@ -1,12 +1,11 @@
-import { motionValue as e } from "../../value/index.js";
-import { animateMotionValue as t } from "../interfaces/motion-value.js";
+import { animateMotionValue as e } from "../interfaces/motion-value.js";
+import { motionValue as t } from "../../value/index.js";
 import { isMotionValue as n } from "../../value/utils/is-motion-value.js";
-//#region node_modules/motion-dom/dist/es/animation/animate/single-value.mjs
+// node_modules/motion-dom/dist/es/animation/animate/single-value.mjs
 function r(r, i, a) {
-	let o = n(r) ? r : e(r);
-	return o.start(t("", o, i, a)), o.animation;
+	let o = n(r) ? r : t(r);
+	return o.start(e("", o, i, a)), o.animation;
 }
-//#endregion
 export { r as animateSingleValue };
 
 //# sourceMappingURL=single-value.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"single-value.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;;;AAIA,SAAS,EAAmB,GAAO,GAAW,GAAS;CACnD,IAAM,IAAgB,EAAc,EAAM,GAAG,IAAQ,EAAY,EAAM;AAEvE,QADA,EAAc,MAAM,EAAmB,IAAI,GAAe,GAAW,EAAQ,CAAC,EACvE,EAAc"}
+{"version":3,"file":"single-value.js","names":["animateSingleValue","motionValue$1","isMotionValue","value","motionValue","animateMotionValue","keyframes","options"],"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"],"ignoreList":[0],"mappings":";;;;AAIA,SAASA,EAAmB,GAAO,GAAW,GAAS;CACnD,IAAMC,IAAgBC,EAAcC,CAAK,IAAIA,IAAQC,EAAYD,CAAK;CAEtE,OADAF,EAAc,MAAMI,EAAmB,IAAIJ,GAAeK,GAAWC,CAAO,CAAC,GACtEN,EAAc;AACzB"}

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

@@ -1,15 +1,14 @@
-import { cancelFrame as e, frame as t, frameData as n } from "../../frameloop/frame.js";
-import { time as r } from "../../frameloop/sync-time.js";
-//#region node_modules/motion-dom/dist/es/animation/drivers/frame.mjs
+import { time as e } from "../../frameloop/sync-time.js";
+import { cancelFrame as t, frame as n, frameData as r } from "../../frameloop/frame.js";
+// node_modules/motion-dom/dist/es/animation/drivers/frame.mjs
 var i = (i) => {
 	let a = ({ timestamp: e }) => i(e);
 	return {
-		start: (e = !0) => t.update(a, e),
-		stop: () => e(a),
-		now: () => n.isProcessing ? n.timestamp : r.now()
+		start: (e = !0) => n.update(a, e),
+		stop: () => t(a),
+		now: () => r.isProcessing ? r.timestamp : e.now()
 	};
 };
-//#endregion
 export { i as frameloopDriver };
 
 //# sourceMappingURL=frame.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"frame.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;;AAGA,IAAM,KAAmB,MAAW;CAChC,IAAM,KAAiB,EAAE,mBAAgB,EAAO,EAAU;AAC1D,QAAO;EACH,QAAQ,IAAY,OAAS,EAAM,OAAO,GAAe,EAAU;EACnE,YAAY,EAAY,EAAc;EAKtC,WAAY,EAAU,eAAe,EAAU,YAAY,EAAK,KAAK;EACxE"}
+{"version":3,"file":"frame.js","names":["frameloopDriver","passTimestamp","update","timestamp","frame","keepAlive","cancelFrame","frameData","time"],"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"],"ignoreList":[0],"mappings":";;;AAGA,IAAMA,KAAmB,MAAW;CAChC,IAAMC,KAAiB,EAAE,mBAAgBC,EAAOC,CAAS;CACzD,OAAO;EACH,QAAQ,IAAY,OAASC,EAAM,OAAOH,GAAeI,CAAS;EAClE,YAAYC,EAAYL,CAAa;EAKrC,WAAYM,EAAU,eAAeA,EAAU,YAAYC,EAAK,IAAI;CACxE;AACJ"}

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

@@ -1,6 +1,6 @@
 import { spring as e } from "./spring.js";
 import { getGeneratorVelocity as t } from "./utils/velocity.js";
-//#region node_modules/motion-dom/dist/es/animation/generators/inertia.mjs
+// node_modules/motion-dom/dist/es/animation/generators/inertia.mjs
 function n({ keyframes: n, velocity: r = 0, power: i = .8, timeConstant: a = 325, bounceDamping: o = 10, bounceStiffness: s = 500, modifyTarget: c, min: l, max: u, restDelta: d = .5, restSpeed: f }) {
 	let p = n[0], m = {
 		done: !1,
@@ -28,7 +28,6 @@ function n({ keyframes: n, velocity: r = 0, power: i = .8, timeConstant: a = 325
 		}
 	};
 }
-//#endregion
 export { n as inertia };
 
 //# sourceMappingURL=inertia.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"inertia.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;;AAGA,SAAS,EAAQ,EAAE,cAAW,cAAW,GAAK,WAAQ,IAAK,kBAAe,KAAK,mBAAgB,IAAI,qBAAkB,KAAK,iBAAc,QAAK,QAAK,eAAY,IAAK,gBAAc;CAC7K,IAAM,IAAS,EAAU,IACnB,IAAQ;EACV,MAAM;EACN,OAAO;EACV,EACK,KAAiB,MAAO,MAAQ,KAAA,KAAa,IAAI,KAAS,MAAQ,KAAA,KAAa,IAAI,GACnF,KAAmB,MACjB,MAAQ,KAAA,IACD,IACP,MAAQ,KAAA,KAEL,KAAK,IAAI,IAAM,EAAE,GAAG,KAAK,IAAI,IAAM,EAAE,GADjC,IAC0C,GAErD,IAAY,IAAQ,GAClB,IAAQ,IAAS,GACjB,IAAS,MAAiB,KAAA,IAAY,IAAQ,EAAa,EAAM;AAKvE,CAAI,MAAW,MACX,IAAY,IAAS;CACzB,IAAM,KAAa,MAAM,CAAC,IAAY,KAAK,IAAI,CAAC,IAAI,EAAa,EAC3D,KAAc,MAAM,IAAS,EAAU,EAAE,EACzC,KAAiB,MAAM;EACzB,IAAM,IAAQ,EAAU,EAAE,EACpB,IAAS,EAAW,EAAE;AAE5B,EADA,EAAM,OAAO,KAAK,IAAI,EAAM,IAAI,GAChC,EAAM,QAAQ,EAAM,OAAO,IAAS;IAQpC,GACA,GACE,KAAsB,MAAM;AACzB,IAAc,EAAM,MAAM,KAE/B,IAAsB,GACtB,IAAW,EAAO;GACd,WAAW,CAAC,EAAM,OAAO,EAAgB,EAAM,MAAM,CAAC;GACtD,UAAU,EAAqB,GAAY,GAAG,EAAM,MAAM;GAC1D,SAAS;GACT,WAAW;GACX;GACA;GACH,CAAC;;AAGN,QADA,EAAmB,EAAE,EACd;EACH,oBAAoB;EACpB,OAAO,MAAM;GAOT,IAAI,IAAkB;AAelB,UAdA,CAAC,KAAY,MAAwB,KAAA,MACrC,IAAkB,IAClB,EAAc,EAAE,EAChB,EAAmB,EAAE,GAMrB,MAAwB,KAAA,KAAa,KAAK,IACnC,EAAS,KAAK,IAAI,EAAoB,IAG7C,CAAC,KAAmB,EAAc,EAAE,EAC7B;;EAGlB"}
+{"version":3,"file":"inertia.js","names":["inertia","origin","keyframes","state","isOutOfBounds","min","v","max","nearestBoundary","amplitude","power","velocity","ideal","target","modifyTarget","calcDelta","t","timeConstant","calcLatest","applyFriction","delta","latest","restDelta","timeReachedBoundary","spring$1","checkCatchBoundary","spring","getGeneratorVelocity","bounceDamping","bounceStiffness","hasUpdatedFrame"],"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"],"ignoreList":[0],"mappings":";;;AAGA,SAASA,EAAQ,EAAE,cAAW,cAAW,GAAK,WAAQ,IAAK,kBAAe,KAAK,mBAAgB,IAAI,qBAAkB,KAAK,iBAAc,QAAK,QAAK,eAAY,IAAK,gBAAc;CAC7K,IAAMC,IAASC,EAAU,IACnBC,IAAQ;EACV,MAAM;EACN,OAAOF;CACX,GACMG,KAAiB,MAAOC,MAAQ,KAAA,KAAaC,IAAID,KAASE,MAAQ,KAAA,KAAaD,IAAIC,GACnFC,KAAmB,MACjBH,MAAQ,KAAA,IACDE,IACPA,MAAQ,KAAA,KAEL,KAAK,IAAIF,IAAMC,CAAC,IAAI,KAAK,IAAIC,IAAMD,CAAC,IADhCD,IAC0CE,GAErDE,IAAYC,IAAQC,GAClBC,IAAQX,IAASQ,GACjBI,IAASC,MAAiB,KAAA,IAAYF,IAAQE,EAAaF,CAAK;CAKtE,AAAIC,MAAWD,MACX,IAAYC,IAASZ;CACzB,IAAMc,KAAa,MAAM,CAACN,IAAY,KAAK,IAAI,CAACO,IAAIC,CAAY,GAC1DC,KAAc,MAAML,IAASE,EAAUC,CAAC,GACxCG,KAAiB,MAAM;EACzB,IAAMC,IAAQL,EAAUC,CAAC,GACnBK,IAASH,EAAWF,CAAC;EAE3B,AADA,EAAM,OAAO,KAAK,IAAII,CAAK,KAAKE,GAChC,EAAM,QAAQnB,EAAM,OAAOU,IAASQ;CACxC,GAOIE,GACAC,GACEC,KAAsB,MAAM;EAC9B,AAAKrB,EAAcD,EAAM,KAAK,MAE9B,IAAsBa,GACtB,IAAWU,EAAO;GACd,WAAW,CAACvB,EAAM,OAAOK,EAAgBL,EAAM,KAAK,CAAC;GACrD,UAAUwB,EAAqBT,GAAYF,GAAGb,EAAM,KAAK;GACzD,SAASyB;GACT,WAAWC;GACX;GACA;EACJ,CAAC;CACL;CAEA,OADAJ,EAAmB,CAAC,GACb;EACH,oBAAoB;EACpB,OAAO,MAAM;GAOT,IAAIK,IAAkB;GAelB,OAdA,CAACN,KAAYD,MAAwB,KAAA,MACrC,IAAkB,IAClBJ,EAAcH,CAAC,GACfS,EAAmBT,CAAC,IAMpBO,MAAwB,KAAA,KAAaP,KAAKO,IACnCC,EAAS,KAAKR,IAAIO,CAAmB,KAG5C,CAACO,KAAmBX,EAAcH,CAAC,GAC5Bb;EAEf;CACJ;AACJ"}

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

@@ -4,7 +4,7 @@ import { easingDefinitionToFunction as n } from "../../../../../motion-utils/dis
 import { interpolate as r } from "../../utils/interpolate.js";
 import { defaultOffset as i } from "../keyframes/offsets/default.js";
 import { convertOffsetToTimes as a } from "../keyframes/offsets/time.js";
-//#region node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs
+// node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs
 function o(t, n) {
 	return t.map(() => n || e).splice(0, t.length - 1);
 }
@@ -12,13 +12,12 @@ function s({ duration: e = 300, keyframes: s, times: c, ease: l = "easeInOut" })
 	let u = t(l) ? l.map(n) : n(l), d = {
 		done: !1,
 		value: s[0]
-	}, f = r(a(c && c.length === s.length ? c : i(s), e), s, { ease: Array.isArray(u) ? u : o(s, u) });
+	}, f = a(c && c.length === s.length ? c : i(s), e), p = r(f, s, { ease: Array.isArray(u) ? u : o(s, u) });
 	return {
 		calculatedDuration: e,
-		next: (t) => (d.value = f(t), d.done = t >= e, d)
+		next: (t) => (d.value = p(t), d.done = t >= e, d)
 	};
 }
-//#endregion
-export { s as keyframes };
+export { o as defaultEasing, s as keyframes };
 
 //# sourceMappingURL=keyframes.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"keyframes.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAKA,SAAS,EAAc,GAAQ,GAAQ;AACnC,QAAO,EAAO,UAAU,KAAU,EAAU,CAAC,OAAO,GAAG,EAAO,SAAS,EAAE;;AAE7E,SAAS,EAAU,EAAE,cAAW,KAAK,WAAW,GAAgB,UAAO,UAAO,eAAgB;CAK1F,IAAM,IAAkB,EAAc,EAAK,GACrC,EAAK,IAAI,EAA2B,GACpC,EAA2B,EAAK,EAKhC,IAAQ;EACV,MAAM;EACN,OAAO,EAAe;EACzB,EAUK,IAAoB,EANJ,EAGtB,KAAS,EAAM,WAAW,EAAe,SACnC,IACA,EAAc,EAAe,EAAE,EAAS,EACO,GAAgB,EACjE,MAAM,MAAM,QAAQ,EAAgB,GAC9B,IACA,EAAc,GAAgB,EAAgB,EACvD,CAAC;AACF,QAAO;EACH,oBAAoB;EACpB,OAAO,OACH,EAAM,QAAQ,EAAkB,EAAE,EAClC,EAAM,OAAO,KAAK,GACX;EAEd"}
+{"version":3,"file":"keyframes.js","names":["defaultEasing","values","easing","easeInOut","keyframes","keyframeValues","easingFunctions","isEasingArray","ease","easingDefinitionToFunction","state","absoluteTimes","convertOffsetToTimes","times","defaultOffset","duration","mapTimeToKeyframe","interpolate"],"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"],"ignoreList":[0],"mappings":";;;;;;;AAKA,SAASA,EAAc,GAAQ,GAAQ;CACnC,OAAOC,EAAO,UAAUC,KAAUC,CAAS,CAAC,CAAC,OAAO,GAAGF,EAAO,SAAS,CAAC;AAC5E;AACA,SAASG,EAAU,EAAE,cAAW,KAAK,WAAWC,GAAgB,UAAO,UAAO,eAAgB;CAK1F,IAAMC,IAAkBC,EAAcC,CAAI,IACpCA,EAAK,IAAIC,CAA0B,IACnCA,EAA2BD,CAAI,GAK/BE,IAAQ;EACV,MAAM;EACN,OAAOL,EAAe;CAC1B,GAIMM,IAAgBC,EAGtBC,KAASA,EAAM,WAAWR,EAAe,SACnCQ,IACAC,EAAcT,CAAc,GAAGU,CAAQ,GACvCC,IAAoBC,EAAYN,GAAeN,GAAgB,EACjE,MAAM,MAAM,QAAQC,CAAe,IAC7BA,IACAN,EAAcK,GAAgBC,CAAe,EACvD,CAAC;CACD,OAAO;EACH,oBAAoBS;EACpB,OAAO,OACH,EAAM,QAAQC,EAAkB,CAAC,GACjC,EAAM,OAAO,KAAKD,GACXL;CAEf;AACJ"}

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

@@ -1,10 +1,10 @@
-import { clamp as e } from "../../../../../motion-utils/dist/es/clamp.js";
-import { warning as t } from "../../../../../motion-utils/dist/es/errors.js";
-import { millisecondsToSeconds as n, secondsToMilliseconds as r } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { millisecondsToSeconds as e, secondsToMilliseconds as t } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { clamp as n } from "../../../../../motion-utils/dist/es/clamp.js";
+import { warning as r } from "../../../../../motion-utils/dist/es/errors.js";
 import { generateLinearEasing as i } from "../waapi/utils/linear.js";
 import { calcGeneratorDuration as a, maxGeneratorDuration as o } from "./utils/calc-duration.js";
 import { createGeneratorEasing as s } from "./utils/create-generator-easing.js";
-//#region node_modules/motion-dom/dist/es/animation/generators/spring.mjs
+// node_modules/motion-dom/dist/es/animation/generators/spring.mjs
 var c = {
 	stiffness: 100,
 	damping: 10,
@@ -38,20 +38,17 @@ function d(e, t, n) {
 var f = .001;
 function p({ duration: i = c.duration, bounce: a = c.bounce, velocity: o = c.velocity, mass: s = c.mass }) {
 	let u, p;
-	t(i <= r(c.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+	r(i <= t(c.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
 	let m = 1 - a;
-	m = e(c.minDamping, c.maxDamping, m), i = e(c.minDuration, c.maxDuration, n(i)), m < 1 ? (u = (e) => {
+	m = n(c.minDamping, c.maxDamping, m), i = n(c.minDuration, c.maxDuration, e(i)), m < 1 ? (u = (e) => {
 		let t = e * m, n = t * i, r = t - o, a = l(e, m), s = Math.exp(-n);
 		return f - r / a * s;
 	}, p = (e) => {
 		let t = e * m * i, n = t * o + o, r = m ** 2 * e ** 2 * i, a = Math.exp(-t), s = l(e ** 2, m);
 		return (-u(e) + f > 0 ? -1 : 1) * ((n - r) * a) / s;
-	}) : (u = (e) => {
-		let t = Math.exp(-e * i), n = (e - o) * i + 1;
-		return -f + t * n;
-	}, p = (e) => Math.exp(-e * i) * ((o - e) * (i * i)));
+	}) : (u = (e) => -.001 + Math.exp(-e * i) * ((e - o) * i + 1), p = (e) => Math.exp(-e * i) * ((o - e) * (i * i)));
 	let h = 5 / i, g = d(u, p, h);
-	if (i = r(i), isNaN(g)) return {
+	if (i = t(i), isNaN(g)) return {
 		stiffness: c.stiffness,
 		damping: c.damping,
 		duration: i
@@ -73,51 +70,56 @@ var m = ["duration", "bounce"], h = [
 function g(e, t) {
 	return t.some((t) => e[t] !== void 0);
 }
-function _(t) {
-	let n = {
+function _(e) {
+	let t = {
 		velocity: c.velocity,
 		stiffness: c.stiffness,
 		damping: c.damping,
 		mass: c.mass,
 		isResolvedFromDuration: !1,
-		...t
+		...e
 	};
-	if (!g(t, h) && g(t, m)) if (n.velocity = 0, t.visualDuration) {
-		let r = t.visualDuration, i = 2 * Math.PI / (r * 1.2), a = i * i, o = 2 * e(.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(a);
-		n = {
-			...n,
-			mass: c.mass,
-			stiffness: a,
-			damping: o
-		};
-	} else {
-		let e = p({
-			...t,
-			velocity: 0
-		});
-		n = {
-			...n,
-			...e,
-			mass: c.mass
-		}, n.isResolvedFromDuration = !0;
+	if (!g(e, h) && g(e, m)) {
+		if (t.velocity = 0, e.visualDuration) {
+			let r = e.visualDuration, i = 2 * Math.PI / (r * 1.2), a = i * i, o = 2 * n(.05, 1, 1 - (e.bounce || 0)) * Math.sqrt(a);
+			t = {
+				...t,
+				mass: c.mass,
+				stiffness: a,
+				damping: o
+			};
+		} else {
+			let n = p({
+				...e,
+				velocity: 0
+			});
+			t = {
+				...t,
+				...n,
+				mass: c.mass
+			}, t.isResolvedFromDuration = !0;
+		}
 	}
-	return n;
+	return t;
 }
-function v(e = c.visualDuration, t = c.bounce) {
-	let s = typeof e == "object" ? e : {
-		visualDuration: e,
+function v(n = c.visualDuration, r = c.bounce) {
+	let s = typeof n == "object" ? n : {
+		visualDuration: n,
 		keyframes: [0, 1],
-		bounce: t
+		bounce: r
 	}, { restSpeed: u, restDelta: d } = s, f = s.keyframes[0], p = s.keyframes[s.keyframes.length - 1], m = {
 		done: !1,
 		value: f
 	}, { stiffness: h, damping: g, mass: v, duration: y, velocity: b, isResolvedFromDuration: x } = _({
 		...s,
-		velocity: -n(s.velocity || 0)
-	}), S = b || 0, C = g / (2 * Math.sqrt(h * v)), w = p - f, T = n(Math.sqrt(h / v)), E = Math.abs(w) < 5;
+		velocity: -e(s.velocity || 0)
+	}), S = b || 0, C = g / (2 * Math.sqrt(h * v)), w = p - f, T = e(Math.sqrt(h / v)), E = Math.abs(w) < 5;
 	u ||= E ? c.restSpeed.granular : c.restSpeed.default, d ||= E ? c.restDelta.granular : c.restDelta.default;
 	let D, O, k, A, j, M;
-	if (C < 1) k = l(T, C), A = (S + C * T * w) / k, D = (e) => p - Math.exp(-C * T * e) * (A * Math.sin(k * e) + w * Math.cos(k * e)), j = C * T * A + w * k, M = C * T * w - A * k, O = (e) => Math.exp(-C * T * e) * (j * Math.sin(k * e) + M * Math.cos(k * e));
+	if (C < 1) k = l(T, C), A = (S + C * T * w) / k, D = (e) => {
+		let t = Math.exp(-C * T * e);
+		return p - t * (A * Math.sin(k * e) + w * Math.cos(k * e));
+	}, j = C * T * A + w * k, M = C * T * w - A * k, O = (e) => Math.exp(-C * T * e) * (j * Math.sin(k * e) + M * Math.cos(k * e));
 	else if (C === 1) {
 		D = (e) => p - Math.exp(-T * e) * (w + (S + T * w) * e);
 		let e = S + T * w;
@@ -136,19 +138,19 @@ function v(e = c.visualDuration, t = c.bounce) {
 	}
 	let N = {
 		calculatedDuration: x && y || null,
-		velocity: (e) => r(O(e)),
+		velocity: (e) => t(O(e)),
 		next: (e) => {
 			if (!x && C < 1) {
-				let t = Math.exp(-C * T * e), n = Math.sin(k * e), i = Math.cos(k * e), a = p - t * (A * n + w * i), o = r(t * (j * n + M * i));
+				let n = Math.exp(-C * T * e), r = Math.sin(k * e), i = Math.cos(k * e), a = p - n * (A * r + w * i), o = t(n * (j * r + M * i));
 				return m.done = Math.abs(o) <= u && Math.abs(p - a) <= d, m.value = m.done ? p : a, m;
 			}
-			let t = D(e);
+			let n = D(e);
 			if (x) m.done = e >= y;
 			else {
-				let n = r(O(e));
-				m.done = Math.abs(n) <= u && Math.abs(p - t) <= d;
+				let r = t(O(e));
+				m.done = Math.abs(r) <= u && Math.abs(p - n) <= d;
 			}
-			return m.value = m.done ? p : t, m;
+			return m.value = m.done ? p : n, m;
 		},
 		toString: () => {
 			let e = Math.min(a(N), o), t = i((t) => N.next(e * t).value, e, 30);
@@ -159,10 +161,9 @@ function v(e = c.visualDuration, t = c.bounce) {
 	return N;
 }
 v.applyToOptions = (e) => {
-	let t = s(e, 100, v);
-	return e.ease = t.ease, e.duration = r(t.duration), e.type = "keyframes", e;
+	let n = s(e, 100, v);
+	return e.ease = n.ease, e.duration = t(n.duration), e.type = "keyframes", e;
 };
-//#endregion
 export { v as spring };
 
 //# sourceMappingURL=spring.js.map