@burdenoff/microfe-mybodyshield 2026.705.2 → 2026.706.2

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

@@ -0,0 +1,86 @@
+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 { 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 {
+	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;
+		this.isPseudoElement = !!s, this.allowFlatten = u, this.options = t, e(typeof t.type != "string", "Mini animate() doesn't support \"type\" as a string.", "mini-spring");
+		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();
+			}
+			f?.(), this.notifyFinished();
+		};
+	}
+	play() {
+		this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
+	}
+	pause() {
+		this.animation.pause();
+	}
+	complete() {
+		this.animation.finish?.();
+	}
+	cancel() {
+		try {
+			this.animation.cancel();
+		} catch {}
+	}
+	stop() {
+		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());
+	}
+	commitStyles() {
+		let e = this.options?.element;
+		!this.isPseudoElement && e?.isConnected && this.animation.commitStyles?.();
+	}
+	get duration() {
+		let e = this.animation.effect?.getComputedTiming?.().duration || 0;
+		return n(Number(e));
+	}
+	get iterationDuration() {
+		let { delay: e = 0 } = this.options || {};
+		return this.duration + n(e);
+	}
+	get time() {
+		return n(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();
+	}
+	get speed() {
+		return this.animation.playbackRate;
+	}
+	set speed(e) {
+		e < 0 && (this.finishedTime = null), this.animation.playbackRate = e;
+	}
+	get state() {
+		return this.finishedTime === null ? this.animation.playState : "finished";
+	}
+	get startTime() {
+		return this.manualStartTime ?? Number(this.animation.startTime);
+	}
+	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);
+	}
+};
+//#endregion
+export { u as NativeAnimation };
+
+//# sourceMappingURL=NativeAnimation.js.map

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

@@ -0,0 +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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"}

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

@@ -0,0 +1,30 @@
+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 { JSAnimation as r } from "./JSAnimation.js";
+import { setStyle as i } from "../render/dom/style-set.js";
+import { NativeAnimation as a } from "./NativeAnimation.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 {
+	constructor(e) {
+		o(e), n(e), super(e), e.startTime !== void 0 && e.autoplay !== !1 && (this.startTime = e.startTime), this.options = e;
+	}
+	updateMotionValue(n) {
+		let { motionValue: a, onUpdate: o, onComplete: c, element: l, ...u } = this.options;
+		if (!a) return;
+		if (n !== void 0) {
+			a.set(n);
+			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();
+	}
+};
+//#endregion
+export { c as NativeAnimationExtended };
+
+//# sourceMappingURL=NativeAnimationExtended.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,12 @@
+import { motionValue as e } from "../../value/index.js";
+import { animateMotionValue as t } from "../interfaces/motion-value.js";
+import { isMotionValue as n } from "../../value/utils/is-motion-value.js";
+//#region 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;
+}
+//#endregion
+export { r as animateSingleValue };
+
+//# sourceMappingURL=single-value.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,15 @@
+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
+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()
+	};
+};
+//#endregion
+export { i as frameloopDriver };
+
+//# sourceMappingURL=frame.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,34 @@
+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
+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,
+		value: p
+	}, h = (e) => l !== void 0 && e < l || u !== void 0 && e > u, g = (e) => l === void 0 ? u : u === void 0 || Math.abs(l - e) < Math.abs(u - e) ? l : u, _ = i * r, v = p + _, y = c === void 0 ? v : c(v);
+	y !== v && (_ = y - p);
+	let b = (e) => -_ * Math.exp(-e / a), x = (e) => y + b(e), S = (e) => {
+		let t = b(e), n = x(e);
+		m.done = Math.abs(t) <= d, m.value = m.done ? y : n;
+	}, C, w, T = (n) => {
+		h(m.value) && (C = n, w = e({
+			keyframes: [m.value, g(m.value)],
+			velocity: t(x, n, m.value),
+			damping: o,
+			stiffness: s,
+			restDelta: d,
+			restSpeed: f
+		}));
+	};
+	return T(0), {
+		calculatedDuration: null,
+		next: (e) => {
+			let t = !1;
+			return !w && C === void 0 && (t = !0, S(e), T(e)), C !== void 0 && e >= C ? w.next(e - C) : (!t && S(e), m);
+		}
+	};
+}
+//#endregion
+export { n as inertia };
+
+//# sourceMappingURL=inertia.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,24 @@
+import { easeInOut as e } from "../../../../../motion-utils/dist/es/easing/ease.js";
+import { isEasingArray as t } from "../../../../../motion-utils/dist/es/easing/utils/is-easing-array.js";
+import { easingDefinitionToFunction as n } from "../../../../../motion-utils/dist/es/easing/utils/map.js";
+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
+function o(t, n) {
+	return t.map(() => n || e).splice(0, t.length - 1);
+}
+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) });
+	return {
+		calculatedDuration: e,
+		next: (t) => (d.value = f(t), d.done = t >= e, d)
+	};
+}
+//#endregion
+export { s as keyframes };
+
+//# sourceMappingURL=keyframes.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,168 @@
+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 { 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
+var c = {
+	stiffness: 100,
+	damping: 10,
+	mass: 1,
+	velocity: 0,
+	duration: 800,
+	bounce: .3,
+	visualDuration: .3,
+	restSpeed: {
+		granular: .01,
+		default: 2
+	},
+	restDelta: {
+		granular: .005,
+		default: .5
+	},
+	minDuration: .01,
+	maxDuration: 10,
+	minDamping: .05,
+	maxDamping: 1
+};
+function l(e, t) {
+	return e * Math.sqrt(1 - t * t);
+}
+var u = 12;
+function d(e, t, n) {
+	let r = n;
+	for (let n = 1; n < u; n++) r -= e(r) / t(r);
+	return r;
+}
+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");
+	let m = 1 - a;
+	m = e(c.minDamping, c.maxDamping, m), i = e(c.minDuration, c.maxDuration, n(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)));
+	let h = 5 / i, g = d(u, p, h);
+	if (i = r(i), isNaN(g)) return {
+		stiffness: c.stiffness,
+		damping: c.damping,
+		duration: i
+	};
+	{
+		let e = g ** 2 * s;
+		return {
+			stiffness: e,
+			damping: m * 2 * Math.sqrt(s * e),
+			duration: i
+		};
+	}
+}
+var m = ["duration", "bounce"], h = [
+	"stiffness",
+	"damping",
+	"mass"
+];
+function g(e, t) {
+	return t.some((t) => e[t] !== void 0);
+}
+function _(t) {
+	let n = {
+		velocity: c.velocity,
+		stiffness: c.stiffness,
+		damping: c.damping,
+		mass: c.mass,
+		isResolvedFromDuration: !1,
+		...t
+	};
+	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;
+	}
+	return n;
+}
+function v(e = c.visualDuration, t = c.bounce) {
+	let s = typeof e == "object" ? e : {
+		visualDuration: e,
+		keyframes: [0, 1],
+		bounce: t
+	}, { 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;
+	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));
+	else if (C === 1) {
+		D = (e) => p - Math.exp(-T * e) * (w + (S + T * w) * e);
+		let e = S + T * w;
+		O = (t) => Math.exp(-T * t) * (T * e * t - S);
+	} else {
+		let e = T * Math.sqrt(C * C - 1);
+		D = (t) => {
+			let n = Math.exp(-C * T * t), r = Math.min(e * t, 300);
+			return p - n * ((S + C * T * w) * Math.sinh(r) + e * w * Math.cosh(r)) / e;
+		};
+		let t = (S + C * T * w) / e, n = C * T * t - w * e, r = C * T * w - t * e;
+		O = (t) => {
+			let i = Math.exp(-C * T * t), a = Math.min(e * t, 300);
+			return i * (n * Math.sinh(a) + r * Math.cosh(a));
+		};
+	}
+	let N = {
+		calculatedDuration: x && y || null,
+		velocity: (e) => r(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));
+				return m.done = Math.abs(o) <= u && Math.abs(p - a) <= d, m.value = m.done ? p : a, m;
+			}
+			let t = 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;
+			}
+			return m.value = m.done ? p : t, m;
+		},
+		toString: () => {
+			let e = Math.min(a(N), o), t = i((t) => N.next(e * t).value, e, 30);
+			return e + "ms " + t;
+		},
+		toTransition: () => {}
+	};
+	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;
+};
+//#endregion
+export { v as spring };
+
+//# sourceMappingURL=spring.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spring.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+//#region node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs
+var e = 2e4;
+function t(e) {
+	let t = 0, n = e.next(t);
+	for (; !n.done && t < 2e4;) t += 50, n = e.next(t);
+	return t >= 2e4 ? Infinity : t;
+}
+//#endregion
+export { t as calcGeneratorDuration, e as maxGeneratorDuration };
+
+//# sourceMappingURL=calc-duration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calc-duration.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";AAIA,IAAM,IAAuB;AAC7B,SAAS,EAAsB,GAAW;CACtC,IAAI,IAAW,GAEX,IAAQ,EAAU,KAAK,EAAS;AACpC,QAAO,CAAC,EAAM,QAAQ,IAAA,KAElB,CADA,KAAY,IACZ,IAAQ,EAAU,KAAK,EAAS;AAEpC,QAAO,KAAA,MAAmC,WAAW"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-generator-easing.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;;AAMA,SAAS,EAAsB,GAAS,IAAQ,KAAK,GAAiB;CAClE,IAAM,IAAY,EAAgB;EAAE,GAAG;EAAS,WAAW,CAAC,GAAG,EAAM;EAAE,CAAC,EAClE,IAAW,KAAK,IAAI,EAAsB,EAAU,EAAE,EAAqB;AACjF,QAAO;EACH,MAAM;EACN,OAAO,MACI,EAAU,KAAK,IAAW,EAAS,CAAC,QAAQ;EAEvD,UAAU,EAAsB,EAAS;EAC5C"}

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

@@ -0,0 +1,8 @@
+//#region node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs
+function e(e) {
+	return typeof e == "function" && "applyToOptions" in e;
+}
+//#endregion
+export { e as isGenerator };
+
+//# sourceMappingURL=is-generator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-generator.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAS,EAAY,GAAM;AACvB,QAAO,OAAO,KAAS,cAAc,oBAAoB"}

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

@@ -0,0 +1,11 @@
+import { velocityPerSecond as e } from "../../../../../../motion-utils/dist/es/velocity-per-second.js";
+//#region node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs
+var t = 5;
+function n(n, r, i) {
+	let a = Math.max(r - t, 0);
+	return e(i - n(a), r - a);
+}
+//#endregion
+export { n as getGeneratorVelocity };
+
+//# sourceMappingURL=velocity.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"velocity.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;AAEA,IAAM,IAAyB;AAC/B,SAAS,EAAqB,GAAc,GAAG,GAAS;CACpD,IAAM,IAAQ,KAAK,IAAI,IAAI,GAAwB,EAAE;AACrD,QAAO,EAAkB,IAAU,EAAa,EAAM,EAAE,IAAI,EAAM"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"motion-value.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;AAUA,IAAM,KAAsB,GAAM,GAAO,GAAQ,IAAa,EAAE,EAAE,GAAS,OAAe,MAAe;CACrG,IAAM,IAAkB,EAAmB,GAAY,EAAK,IAAI,EAAE,EAM5D,IAAQ,EAAgB,SAAS,EAAW,SAAS,GAKvD,EAAE,aAAU,MAAM;AACtB,MAAoB,EAAsB,EAAM;CAChD,IAAM,IAAU;EACZ,WAAW,MAAM,QAAQ,EAAO,GAAG,IAAS,CAAC,MAAM,EAAO;EAC1D,MAAM;EACN,UAAU,EAAM,aAAa;EAC7B,GAAG;EACH,OAAO,CAAC;EACR,WAAW,MAAM;AAEb,GADA,EAAM,IAAI,EAAE,EACZ,EAAgB,YAAY,EAAgB,SAAS,EAAE;;EAE3D,kBAAkB;AAEd,GADA,GAAY,EACZ,EAAgB,cAAc,EAAgB,YAAY;;EAE9D;EACA,aAAa;EACb,SAAS,IAAY,KAAA,IAAY;EACpC;AAkBD,CAbK,EAAoB,EAAgB,IACrC,OAAO,OAAO,GAAS,EAAqB,GAAM,EAAQ,CAAC,EAO/D,AAAqB,EAAQ,aAAW,EAAsB,EAAQ,SAAS,EAC/E,AAAwB,EAAQ,gBAAc,EAAsB,EAAQ,YAAY,EAIpF,EAAQ,SAAS,KAAA,MACjB,EAAQ,UAAU,KAAK,EAAQ;CAEnC,IAAI,IAAa;AA0BjB,MAzBI,EAAQ,SAAS,MAChB,EAAQ,aAAa,KAAK,CAAC,EAAQ,iBACpC,EAAqB,EAAQ,EACzB,EAAQ,UAAU,MAClB,IAAa,OAGjB,EAAmB,qBACnB,EAAmB,kBACnB,GAAS,wBACT,EAAgB,oBAChB,IAAa,IACb,EAAqB,EAAQ,EAC7B,EAAQ,QAAQ,IAMpB,EAAQ,eAAe,CAAC,EAAgB,QAAQ,CAAC,EAAgB,MAM7D,KAAc,CAAC,KAAa,EAAM,KAAK,KAAK,KAAA,GAAW;EACvD,IAAM,IAAgB,EAAiB,EAAQ,WAAW,EAAgB;AAC1E,MAAI,MAAkB,KAAA,GAAW;AAC7B,KAAM,aAAa;AAEf,IADA,EAAQ,SAAS,EAAc,EAC/B,EAAQ,YAAY;KACtB;AACF;;;AAGR,QAAO,EAAgB,SACjB,IAAI,EAAY,EAAQ,GACxB,IAAI,EAA0B,EAAQ"}