@hirely/ui 0.1.6 → 0.1.8

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/JSAnimation.es.js

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

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/JSAnimation.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSAnimation.es.js","names":[],"sources":["../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/JSAnimation.mjs"],"sourcesContent":["import { invariant, pipe, clamp, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { mix } from '../utils/mix/index.mjs';\nimport { frameloopDriver } from './drivers/frame.mjs';\nimport { inertia } from './generators/inertia.mjs';\nimport { keyframes } from './generators/keyframes.mjs';\nimport { calcGeneratorDuration } from './generators/utils/calc-duration.mjs';\nimport { getGeneratorVelocity } from './generators/utils/velocity.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\n\nconst percentToProgress = (percent) => percent / 100;\nclass JSAnimation extends WithPromise {\n    constructor(options) {\n        super();\n        this.state = \"idle\";\n        this.startTime = null;\n        this.isStopped = false;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * Reusable state object for the delay phase to avoid\n         * allocating a new object every frame.\n         */\n        this.delayState = {\n            done: false,\n            value: undefined,\n        };\n        /**\n         * This method is bound to the instance to fix a pattern where\n         * animation.stop is returned as a reference from a useEffect.\n         */\n        this.stop = () => {\n            const { motionValue } = this.options;\n            if (motionValue && motionValue.updatedAt !== time.now()) {\n                this.tick(time.now());\n            }\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            this.options.onStop?.();\n        };\n        this.options = options;\n        this.initAnimation();\n        this.play();\n        if (options.autoplay === false)\n            this.pause();\n    }\n    initAnimation() {\n        const { options } = this;\n        replaceTransitionType(options);\n        const { type = keyframes, repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = options;\n        let { keyframes: keyframes$1 } = options;\n        const generatorFactory = type || keyframes;\n        if (process.env.NODE_ENV !== \"production\" &&\n            generatorFactory !== keyframes) {\n            invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`, \"spring-two-frames\");\n        }\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            this.mixKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...options, keyframes: keyframes$1 });\n        /**\n         * If we have a mirror repeat type we need to create a second generator that outputs the\n         * mirrored (not reversed) animation and later ping pong between the two generators.\n         */\n        if (repeatType === \"mirror\") {\n            this.mirroredGenerator = generatorFactory({\n                ...options,\n                keyframes: [...keyframes$1].reverse(),\n                velocity: -velocity,\n            });\n        }\n        /**\n         * If duration is undefined and we have repeat options,\n         * we need to calculate a duration from the generator.\n         *\n         * We set it to the generator itself to cache the duration.\n         * Any timeline resolver will need to have already precalculated\n         * the duration by this step.\n         */\n        if (generator.calculatedDuration === null) {\n            generator.calculatedDuration = calcGeneratorDuration(generator);\n        }\n        const { calculatedDuration } = generator;\n        this.calculatedDuration = calculatedDuration;\n        this.resolvedDuration = calculatedDuration + repeatDelay;\n        this.totalDuration = this.resolvedDuration * (repeat + 1) - repeatDelay;\n        this.generator = generator;\n    }\n    updateTime(timestamp) {\n        const animationTime = Math.round(timestamp - this.startTime) * this.playbackSpeed;\n        // Update currentTime\n        if (this.holdTime !== null) {\n            this.currentTime = this.holdTime;\n        }\n        else {\n            // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n            // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n            // example.\n            this.currentTime = animationTime;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { generator, totalDuration, mixKeyframes, mirroredGenerator, resolvedDuration, calculatedDuration, } = this;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay = 0, keyframes, repeat, repeatType, repeatDelay, type, onUpdate, finalKeyframe, } = this.options;\n        /**\n         * requestAnimationFrame timestamps can come through as lower than\n         * the startTime as set by performance.now(). Here we prevent this,\n         * though in the future it could be possible to make setting startTime\n         * a pending operation that gets resolved here.\n         */\n        if (this.speed > 0) {\n            this.startTime = Math.min(this.startTime, timestamp);\n        }\n        else if (this.speed < 0) {\n            this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);\n        }\n        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else {\n            this.updateTime(timestamp);\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.playbackSpeed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.playbackSpeed >= 0\n            ? timeWithoutDelay < 0\n            : timeWithoutDelay > totalDuration;\n        this.currentTime = Math.max(timeWithoutDelay, 0);\n        // If this animation has finished, set the current time  to the total duration.\n        if (this.state === \"finished\" && this.holdTime === null) {\n            this.currentTime = totalDuration;\n        }\n        let elapsed = this.currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        let state;\n        if (isInDelayPhase) {\n            this.delayState.value = keyframes[0];\n            state = this.delayState;\n        }\n        else {\n            state = frameGenerator.next(elapsed);\n        }\n        if (mixKeyframes && !isInDelayPhase) {\n            state.value = mixKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.playbackSpeed >= 0\n                    ? this.currentTime >= totalDuration\n                    : this.currentTime <= 0;\n        }\n        const isAnimationFinished = this.holdTime === null &&\n            (this.state === \"finished\" || (this.state === \"running\" && done));\n        // TODO: The exception for inertia could be cleaner here\n        if (isAnimationFinished && type !== inertia) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.finished.then(resolve, reject);\n    }\n    get duration() {\n        return millisecondsToSeconds(this.calculatedDuration);\n    }\n    get iterationDuration() {\n        const { delay = 0 } = this.options || {};\n        return this.duration + millisecondsToSeconds(delay);\n    }\n    get time() {\n        return millisecondsToSeconds(this.currentTime);\n    }\n    set time(newTime) {\n        newTime = secondsToMilliseconds(newTime);\n        this.currentTime = newTime;\n        if (this.startTime === null ||\n            this.holdTime !== null ||\n            this.playbackSpeed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.playbackSpeed;\n        }\n        if (this.driver) {\n            this.driver.start(false);\n        }\n        else {\n            this.startTime = 0;\n            this.state = \"paused\";\n            this.holdTime = newTime;\n            this.tick(newTime);\n        }\n    }\n    /**\n     * Returns the generator's velocity at the current time in units/second.\n     * Uses the analytical derivative when available (springs), avoiding\n     * the MotionValue's frame-dependent velocity estimation.\n     */\n    getGeneratorVelocity() {\n        const t = this.currentTime;\n        if (t <= 0)\n            return this.options.velocity || 0;\n        if (this.generator.velocity) {\n            return this.generator.velocity(t);\n        }\n        // Fallback: finite difference\n        const current = this.generator.next(t).value;\n        return getGeneratorVelocity((s) => this.generator.next(s).value, t, current);\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        if (hasChanged && this.driver) {\n            this.updateTime(time.now());\n        }\n        this.playbackSpeed = newSpeed;\n        if (hasChanged && this.driver) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, startTime } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        this.options.onPlay?.();\n        const now = this.driver.now();\n        if (this.state === \"finished\") {\n            this.updateFinished();\n            this.startTime = now;\n        }\n        else if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = startTime ?? now;\n        }\n        if (this.state === \"finished\" && this.speed < 0) {\n            this.startTime += this.calculatedDuration;\n        }\n        this.holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        this.state = \"running\";\n        this.driver.start();\n    }\n    pause() {\n        this.state = \"paused\";\n        this.updateTime(time.now());\n        this.holdTime = this.currentTime;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.notifyFinished();\n        this.teardown();\n        this.state = \"finished\";\n        this.options.onComplete?.();\n    }\n    cancel() {\n        this.holdTime = null;\n        this.startTime = 0;\n        this.tick(0);\n        this.teardown();\n        this.options.onCancel?.();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.startTime = this.holdTime = null;\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(sampleTime) {\n        this.startTime = 0;\n        return this.tick(sampleTime, true);\n    }\n    attachTimeline(timeline) {\n        if (this.options.allowFlatten) {\n            this.options.type = \"keyframes\";\n            this.options.ease = \"linear\";\n            this.initAnimation();\n        }\n        this.driver?.stop();\n        return timeline.observe(this);\n    }\n}\n// Legacy function support\nfunction animateValue(options) {\n    return new JSAnimation(options);\n}\n\nexport { JSAnimation, animateValue };\n//# sourceMappingURL=JSAnimation.mjs.map\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/NativeAnimation.cjs.js

@@ -0,0 +1,2 @@
+require("../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/errors.cjs.js"),t=require("../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/noop.cjs.js"),n=require("../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.cjs.js"),r=require("./keyframes/get-final.cjs.js"),i=require("./utils/WithPromise.cjs.js"),a=require("../render/dom/style-set.cjs.js"),o=require("../utils/supports/scroll-timeline.cjs.js"),s=require("./waapi/start-waapi-animation.cjs.js"),c=require("./waapi/utils/apply-generator.cjs.js");var l=class extends i.WithPromise{constructor(t){if(super(),this.finishedTime=null,this.isStopped=!1,this.manualStartTime=null,!t)return;let{element:n,name:i,keyframes:o,pseudoElement:l,allowFlatten:u=!1,finalKeyframe:d,onComplete:f}=t;this.isPseudoElement=!!l,this.allowFlatten=u,this.options=t,e.invariant(typeof t.type!=`string`,`Mini animate() doesn't support "type" as a string.`,`mini-spring`);let p=c.applyGeneratorOptions(t);this.animation=s.startWaapiAnimation(n,i,o,p,l),p.autoplay===!1&&this.animation.pause(),this.animation.onfinish=()=>{if(this.finishedTime=this.time,!l){let e=r.getFinalKeyframe(o,this.options,d,this.speed);this.updateMotionValue&&this.updateMotionValue(e),a.setStyle(n,i,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.millisecondsToSeconds(Number(e))}get iterationDuration(){let{delay:e=0}=this.options||{};return this.duration+n.millisecondsToSeconds(e)}get time(){return n.millisecondsToSeconds(Number(this.animation.currentTime)||0)}set time(e){let t=this.finishedTime!==null;this.manualStartTime=null,this.finishedTime=null,this.animation.currentTime=n.secondsToMilliseconds(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&&o.supportsScrollTimeline()?(this.animation.timeline=e,n&&(this.animation.rangeStart=n),r&&(this.animation.rangeEnd=r),t.noop):i(this)}};exports.NativeAnimation=l;
+//# sourceMappingURL=NativeAnimation.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/NativeAnimation.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAnimation.cjs.js","names":["WithPromise","applyGeneratorOptions","startWaapiAnimation","getFinalKeyframe","millisecondsToSeconds","secondsToMilliseconds","supportsScrollTimeline","noop"],"sources":["../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/NativeAnimation.es.js

@@ -0,0 +1,86 @@
+import { invariant as e } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/errors.es.js";
+import { noop as t } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/noop.es.js";
+import { millisecondsToSeconds as n, secondsToMilliseconds as r } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.es.js";
+import { getFinalKeyframe as i } from "./keyframes/get-final.es.js";
+import { WithPromise as a } from "./utils/WithPromise.es.js";
+import { setStyle as o } from "../render/dom/style-set.es.js";
+import { supportsScrollTimeline as s } from "../utils/supports/scroll-timeline.es.js";
+import { startWaapiAnimation as c } from "./waapi/start-waapi-animation.es.js";
+import { applyGeneratorOptions as l } from "./waapi/utils/apply-generator.es.js";
+//#region ../../node_modules/.bun/motion-dom@12.42.2/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.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAnimation.es.js","names":[],"sources":["../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.cjs.js

@@ -0,0 +1,2 @@
+require("../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/clamp.cjs.js"),t=require("../frameloop/sync-time.cjs.js"),n=require("./utils/replace-transition-type.cjs.js"),r=require("./JSAnimation.cjs.js"),i=require("../render/dom/style-set.cjs.js"),a=require("./NativeAnimation.cjs.js"),o=require("./waapi/utils/unsupported-easing.cjs.js");var s=10,c=class extends a.NativeAnimation{constructor(e){o.replaceStringEasing(e),n.replaceTransitionType(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.JSAnimation({...u,autoplay:!1}),f=Math.max(s,t.time.now()-this.startTime),p=e.clamp(0,s,f-s),m=d.sample(f).value,{name:h}=this.options;l&&h&&i.setStyle(l,h,m),a.setWithVelocity(d.sample(Math.max(0,f-p)).value,m,p),d.stop()}};exports.NativeAnimationExtended=c;
+//# sourceMappingURL=NativeAnimationExtended.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAnimationExtended.cjs.js","names":["NativeAnimation","JSAnimation","time","clamp"],"sources":["../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"sbAaA,IAAM,EAAc,GACd,EAAN,cAAsCA,EAAAA,eAAgB,CAClD,YAAY,EAAS,CAUjB,EAAA,oBAAoB,CAAO,EAQ3B,EAAA,sBAAsB,CAAO,EAC7B,MAAM,CAAO,EAMT,EAAQ,YAAc,IAAA,IAAa,EAAQ,WAAa,KACxD,KAAK,UAAY,EAAQ,WAE7B,KAAK,QAAU,CACnB,CASA,kBAAkB,EAAO,CACrB,GAAM,CAAE,cAAa,WAAU,aAAY,UAAS,GAAG,GAAY,KAAK,QACxE,GAAI,CAAC,EACD,OACJ,GAAI,IAAU,IAAA,GAAW,CACrB,EAAY,IAAI,CAAK,EACrB,MACJ,CACA,IAAM,EAAkB,IAAIC,EAAAA,YAAY,CACpC,GAAG,EACH,SAAU,EACd,CAAC,EAMK,EAAa,KAAK,IAAI,EAAaC,EAAAA,KAAK,IAAI,EAAI,KAAK,SAAS,EAC9D,EAAQC,EAAAA,MAAM,EAAG,EAAa,EAAa,CAAW,EACtD,EAAU,EAAgB,OAAO,CAAU,CAAC,CAAC,MAM7C,CAAE,QAAS,KAAK,QAClB,GAAW,GACX,EAAA,SAAS,EAAS,EAAM,CAAO,EACnC,EAAY,gBAAgB,EAAgB,OAAO,KAAK,IAAI,EAAG,EAAa,CAAK,CAAC,CAAC,CAAC,MAAO,EAAS,CAAK,EACzG,EAAgB,KAAK,CACzB,CACJ"}

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

@@ -0,0 +1,30 @@
+import { clamp as e } from "../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/clamp.es.js";
+import { time as t } from "../frameloop/sync-time.es.js";
+import { replaceTransitionType as n } from "./utils/replace-transition-type.es.js";
+import { JSAnimation as r } from "./JSAnimation.es.js";
+import { setStyle as i } from "../render/dom/style-set.es.js";
+import { NativeAnimation as a } from "./NativeAnimation.es.js";
+import { replaceStringEasing as o } from "./waapi/utils/unsupported-easing.es.js";
+//#region ../../node_modules/.bun/motion-dom@12.42.2/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.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAnimationExtended.es.js","names":[],"sources":["../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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;EA4BjB,AAlBA,EAAoB,CAAO,GAQ3B,EAAsB,CAAO,GAC7B,MAAM,CAAO,GAMT,EAAQ,cAAc,KAAA,KAAa,EAAQ,aAAa,OACxD,KAAK,YAAY,EAAQ,YAE7B,KAAK,UAAU;CACnB;CASA,kBAAkB,GAAO;EACrB,IAAM,EAAE,gBAAa,aAAU,eAAY,YAAS,GAAG,MAAY,KAAK;EACxE,IAAI,CAAC,GACD;EACJ,IAAI,MAAU,KAAA,GAAW;GACrB,EAAY,IAAI,CAAK;GACrB;EACJ;EACA,IAAM,IAAkB,IAAI,EAAY;GACpC,GAAG;GACH,UAAU;EACd,CAAC,GAMK,IAAa,KAAK,IAAI,GAAa,EAAK,IAAI,IAAI,KAAK,SAAS,GAC9D,IAAQ,EAAM,GAAG,GAAa,IAAa,CAAW,GACtD,IAAU,EAAgB,OAAO,CAAU,CAAC,CAAC,OAM7C,EAAE,YAAS,KAAK;EAItB,AAHI,KAAW,KACX,EAAS,GAAS,GAAM,CAAO,GACnC,EAAY,gBAAgB,EAAgB,OAAO,KAAK,IAAI,GAAG,IAAa,CAAK,CAAC,CAAC,CAAC,OAAO,GAAS,CAAK,GACzG,EAAgB,KAAK;CACzB;AACJ"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/animate/single-value.cjs.js

@@ -0,0 +1,2 @@
+require("../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../value/index.cjs.js"),t=require("../interfaces/motion-value.cjs.js"),n=require("../../value/utils/is-motion-value.cjs.js");function r(r,i,a){let o=n.isMotionValue(r)?r:e.motionValue(r);return o.start(t.animateMotionValue(``,o,i,a)),o.animation}exports.animateSingleValue=r;
+//# sourceMappingURL=single-value.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/animate/single-value.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-value.cjs.js","names":["isMotionValue","motionValue","animateMotionValue"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"yNAIA,SAAS,EAAmB,EAAO,EAAW,EAAS,CACnD,IAAM,EAAgBA,EAAAA,cAAc,CAAK,EAAI,EAAQC,EAAAA,YAAY,CAAK,EAEtE,OADA,EAAc,MAAMC,EAAAA,mBAAmB,GAAI,EAAe,EAAW,CAAO,CAAC,EACtE,EAAc,SACzB"}

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

@@ -0,0 +1,12 @@
+import { motionValue as e } from "../../value/index.es.js";
+import { animateMotionValue as t } from "../interfaces/motion-value.es.js";
+import { isMotionValue as n } from "../../value/utils/is-motion-value.es.js";
+//#region ../../node_modules/.bun/motion-dom@12.42.2/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.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"single-value.es.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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,CAAK,IAAI,IAAQ,EAAY,CAAK;CAEtE,OADA,EAAc,MAAM,EAAmB,IAAI,GAAe,GAAW,CAAO,CAAC,GACtE,EAAc;AACzB"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/drivers/frame.cjs.js

@@ -0,0 +1,2 @@
+require("../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../frameloop/frame.cjs.js"),t=require("../../frameloop/sync-time.cjs.js");var n=n=>{let r=({timestamp:e})=>n(e);return{start:(t=!0)=>e.frame.update(r,t),stop:()=>e.cancelFrame(r),now:()=>e.frameData.isProcessing?e.frameData.timestamp:t.time.now()}};exports.frameloopDriver=n;
+//# sourceMappingURL=frame.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/drivers/frame.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.cjs.js","names":["frame","cancelFrame","frameData","time"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"sKAGA,IAAM,EAAmB,GAAW,CAChC,IAAM,GAAiB,CAAE,eAAgB,EAAO,CAAS,EACzD,MAAO,CACH,OAAQ,EAAY,KAASA,EAAAA,MAAM,OAAO,EAAe,CAAS,EAClE,SAAYC,EAAAA,YAAY,CAAa,EAKrC,QAAYC,EAAAA,UAAU,aAAeA,EAAAA,UAAU,UAAYC,EAAAA,KAAK,IAAI,CACxE,CACJ"}

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

@@ -0,0 +1,15 @@
+import { cancelFrame as e, frame as t, frameData as n } from "../../frameloop/frame.es.js";
+import { time as r } from "../../frameloop/sync-time.es.js";
+//#region ../../node_modules/.bun/motion-dom@12.42.2/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.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.es.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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,CAAS;CACzD,OAAO;EACH,QAAQ,IAAY,OAAS,EAAM,OAAO,GAAe,CAAS;EAClE,YAAY,EAAY,CAAa;EAKrC,WAAY,EAAU,eAAe,EAAU,YAAY,EAAK,IAAI;CACxE;AACJ"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/inertia.cjs.js

@@ -0,0 +1,2 @@
+require("../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("./spring.cjs.js"),t=require("./utils/velocity.cjs.js");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.spring({keyframes:[m.value,g(m.value)],velocity:t.getGeneratorVelocity(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)}}}exports.inertia=n;
+//# sourceMappingURL=inertia.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/inertia.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.cjs.js","names":["spring","getGeneratorVelocity"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"gJAGA,SAAS,EAAQ,CAAE,YAAW,WAAW,EAAK,QAAQ,GAAK,eAAe,IAAK,gBAAgB,GAAI,kBAAkB,IAAK,eAAc,MAAK,MAAK,YAAY,GAAK,aAAc,CAC7K,IAAM,EAAS,EAAU,GACnB,EAAQ,CACV,KAAM,GACN,MAAO,CACX,EACM,EAAiB,GAAO,IAAQ,IAAA,IAAa,EAAI,GAAS,IAAQ,IAAA,IAAa,EAAI,EACnF,EAAmB,GACjB,IAAQ,IAAA,GACD,EACP,IAAQ,IAAA,IAEL,KAAK,IAAI,EAAM,CAAC,EAAI,KAAK,IAAI,EAAM,CAAC,EADhC,EAC0C,EAErD,EAAY,EAAQ,EAClB,EAAQ,EAAS,EACjB,EAAS,IAAiB,IAAA,GAAY,EAAQ,EAAa,CAAK,EAKlE,IAAW,IACX,EAAY,EAAS,GACzB,IAAM,EAAa,GAAM,CAAC,EAAY,KAAK,IAAI,CAAC,EAAI,CAAY,EAC1D,EAAc,GAAM,EAAS,EAAU,CAAC,EACxC,EAAiB,GAAM,CACzB,IAAM,EAAQ,EAAU,CAAC,EACnB,EAAS,EAAW,CAAC,EAC3B,EAAM,KAAO,KAAK,IAAI,CAAK,GAAK,EAChC,EAAM,MAAQ,EAAM,KAAO,EAAS,CACxC,EAOI,EACA,EACE,EAAsB,GAAM,CACzB,EAAc,EAAM,KAAK,IAE9B,EAAsB,EACtB,EAAWA,EAAAA,OAAO,CACd,UAAW,CAAC,EAAM,MAAO,EAAgB,EAAM,KAAK,CAAC,EACrD,SAAUC,EAAAA,qBAAqB,EAAY,EAAG,EAAM,KAAK,EACzD,QAAS,EACT,UAAW,EACX,YACA,WACJ,CAAC,EACL,EAEA,OADA,EAAmB,CAAC,EACb,CACH,mBAAoB,KACpB,KAAO,GAAM,CAOT,IAAI,EAAkB,GAelB,MAdA,CAAC,GAAY,IAAwB,IAAA,KACrC,EAAkB,GAClB,EAAc,CAAC,EACf,EAAmB,CAAC,GAMpB,IAAwB,IAAA,IAAa,GAAK,EACnC,EAAS,KAAK,EAAI,CAAmB,GAG5C,CAAC,GAAmB,EAAc,CAAC,EAC5B,EAEf,CACJ,CACJ"}

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

@@ -0,0 +1,34 @@
+import { spring as e } from "./spring.es.js";
+import { getGeneratorVelocity as t } from "./utils/velocity.es.js";
+//#region ../../node_modules/.bun/motion-dom@12.42.2/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.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.es.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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;CACX,GACM,KAAiB,MAAO,MAAQ,KAAA,KAAa,IAAI,KAAS,MAAQ,KAAA,KAAa,IAAI,GACnF,KAAmB,MACjB,MAAQ,KAAA,IACD,IACP,MAAQ,KAAA,KAEL,KAAK,IAAI,IAAM,CAAC,IAAI,KAAK,IAAI,IAAM,CAAC,IADhC,IAC0C,GAErD,IAAY,IAAQ,GAClB,IAAQ,IAAS,GACjB,IAAS,MAAiB,KAAA,IAAY,IAAQ,EAAa,CAAK;CAKtE,AAAI,MAAW,MACX,IAAY,IAAS;CACzB,IAAM,KAAa,MAAM,CAAC,IAAY,KAAK,IAAI,CAAC,IAAI,CAAY,GAC1D,KAAc,MAAM,IAAS,EAAU,CAAC,GACxC,KAAiB,MAAM;EACzB,IAAM,IAAQ,EAAU,CAAC,GACnB,IAAS,EAAW,CAAC;EAE3B,AADA,EAAM,OAAO,KAAK,IAAI,CAAK,KAAK,GAChC,EAAM,QAAQ,EAAM,OAAO,IAAS;CACxC,GAOI,GACA,GACE,KAAsB,MAAM;EACzB,EAAc,EAAM,KAAK,MAE9B,IAAsB,GACtB,IAAW,EAAO;GACd,WAAW,CAAC,EAAM,OAAO,EAAgB,EAAM,KAAK,CAAC;GACrD,UAAU,EAAqB,GAAY,GAAG,EAAM,KAAK;GACzD,SAAS;GACT,WAAW;GACX;GACA;EACJ,CAAC;CACL;CAEA,OADA,EAAmB,CAAC,GACb;EACH,oBAAoB;EACpB,OAAO,MAAM;GAOT,IAAI,IAAkB;GAelB,OAdA,CAAC,KAAY,MAAwB,KAAA,MACrC,IAAkB,IAClB,EAAc,CAAC,GACf,EAAmB,CAAC,IAMpB,MAAwB,KAAA,KAAa,KAAK,IACnC,EAAS,KAAK,IAAI,CAAmB,KAG5C,CAAC,KAAmB,EAAc,CAAC,GAC5B;EAEf;CACJ;AACJ"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/keyframes.cjs.js

@@ -0,0 +1,2 @@
+require("../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/ease.cjs.js"),t=require("../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/is-easing-array.cjs.js"),n=require("../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/map.cjs.js"),r=require("../../utils/interpolate.cjs.js"),i=require("../keyframes/offsets/default.cjs.js"),a=require("../keyframes/offsets/time.cjs.js");function o(t,n){return t.map(()=>n||e.easeInOut).splice(0,t.length-1)}function s({duration:e=300,keyframes:s,times:c,ease:l=`easeInOut`}){let u=t.isEasingArray(l)?l.map(n.easingDefinitionToFunction):n.easingDefinitionToFunction(l),d={done:!1,value:s[0]},f=r.interpolate(a.convertOffsetToTimes(c&&c.length===s.length?c:i.defaultOffset(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)}}exports.defaultEasing=o,exports.keyframes=s;
+//# sourceMappingURL=keyframes.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/keyframes.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyframes.cjs.js","names":["easeInOut","isEasingArray","easingDefinitionToFunction","interpolate","convertOffsetToTimes","defaultOffset"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"mjBAKA,SAAS,EAAc,EAAQ,EAAQ,CACnC,OAAO,EAAO,QAAU,GAAUA,EAAAA,SAAS,CAAC,CAAC,OAAO,EAAG,EAAO,OAAS,CAAC,CAC5E,CACA,SAAS,EAAU,CAAE,WAAW,IAAK,UAAW,EAAgB,QAAO,OAAO,aAAgB,CAK1F,IAAM,EAAkBC,EAAAA,cAAc,CAAI,EACpC,EAAK,IAAIC,EAAAA,0BAA0B,EACnCA,EAAAA,2BAA2B,CAAI,EAK/B,EAAQ,CACV,KAAM,GACN,MAAO,EAAe,EAC1B,EAUM,EAAoBC,EAAAA,YANJC,EAAAA,qBAGtB,GAAS,EAAM,SAAW,EAAe,OACnC,EACAC,EAAAA,cAAc,CAAc,EAAG,CACa,EAAG,EAAgB,CACjE,KAAM,MAAM,QAAQ,CAAe,EAC7B,EACA,EAAc,EAAgB,CAAe,CACvD,CAAC,EACD,MAAO,CACH,mBAAoB,EACpB,KAAO,IACH,EAAM,MAAQ,EAAkB,CAAC,EACjC,EAAM,KAAO,GAAK,EACX,EAEf,CACJ"}

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

@@ -0,0 +1,24 @@
+import { easeInOut as e } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/ease.es.js";
+import { isEasingArray as t } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/is-easing-array.es.js";
+import { easingDefinitionToFunction as n } from "../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/easing/utils/map.es.js";
+import { interpolate as r } from "../../utils/interpolate.es.js";
+import { defaultOffset as i } from "../keyframes/offsets/default.es.js";
+import { convertOffsetToTimes as a } from "../keyframes/offsets/time.es.js";
+//#region ../../node_modules/.bun/motion-dom@12.42.2/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 { o as defaultEasing, s as keyframes };
+
+//# sourceMappingURL=keyframes.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyframes.es.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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;CACnC,OAAO,EAAO,UAAU,KAAU,CAAS,CAAC,CAAC,OAAO,GAAG,EAAO,SAAS,CAAC;AAC5E;AACA,SAAS,EAAU,EAAE,cAAW,KAAK,WAAW,GAAgB,UAAO,UAAO,eAAgB;CAK1F,IAAM,IAAkB,EAAc,CAAI,IACpC,EAAK,IAAI,CAA0B,IACnC,EAA2B,CAAI,GAK/B,IAAQ;EACV,MAAM;EACN,OAAO,EAAe;CAC1B,GAUM,IAAoB,EANJ,EAGtB,KAAS,EAAM,WAAW,EAAe,SACnC,IACA,EAAc,CAAc,GAAG,CACa,GAAG,GAAgB,EACjE,MAAM,MAAM,QAAQ,CAAe,IAC7B,IACA,EAAc,GAAgB,CAAe,EACvD,CAAC;CACD,OAAO;EACH,oBAAoB;EACpB,OAAO,OACH,EAAM,QAAQ,EAAkB,CAAC,GACjC,EAAM,OAAO,KAAK,GACX;CAEf;AACJ"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/spring.cjs.js

@@ -0,0 +1,2 @@
+require("../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/clamp.cjs.js"),t=require("../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/errors.cjs.js"),n=require("../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.cjs.js"),r=require("../waapi/utils/linear.cjs.js"),i=require("./utils/calc-duration.cjs.js"),a=require("./utils/create-generator-easing.cjs.js");var o={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 s(e,t){return e*Math.sqrt(1-t*t)}var c=12;function l(e,t,n){let r=n;for(let n=1;n<c;n++)r-=e(r)/t(r);return r}var u=.001;function d({duration:r=o.duration,bounce:i=o.bounce,velocity:a=o.velocity,mass:c=o.mass}){let d,f;t.warning(r<=n.secondsToMilliseconds(o.maxDuration),`Spring duration must be 10 seconds or less`,`spring-duration-limit`);let p=1-i;p=e.clamp(o.minDamping,o.maxDamping,p),r=e.clamp(o.minDuration,o.maxDuration,n.millisecondsToSeconds(r)),p<1?(d=e=>{let t=e*p,n=t*r,i=t-a,o=s(e,p),c=Math.exp(-n);return u-i/o*c},f=e=>{let t=e*p*r,n=t*a+a,i=p**2*e**2*r,o=Math.exp(-t),c=s(e**2,p);return(-d(e)+u>0?-1:1)*((n-i)*o)/c}):(d=e=>-.001+Math.exp(-e*r)*((e-a)*r+1),f=e=>Math.exp(-e*r)*((a-e)*(r*r)));let m=5/r,h=l(d,f,m);if(r=n.secondsToMilliseconds(r),isNaN(h))return{stiffness:o.stiffness,damping:o.damping,duration:r};{let e=h**2*c;return{stiffness:e,damping:p*2*Math.sqrt(c*e),duration:r}}}var f=[`duration`,`bounce`],p=[`stiffness`,`damping`,`mass`];function m(e,t){return t.some(t=>e[t]!==void 0)}function h(t){let n={velocity:o.velocity,stiffness:o.stiffness,damping:o.damping,mass:o.mass,isResolvedFromDuration:!1,...t};if(!m(t,p)&&m(t,f))if(n.velocity=0,t.visualDuration){let r=t.visualDuration,i=2*Math.PI/(r*1.2),a=i*i,s=2*e.clamp(.05,1,1-(t.bounce||0))*Math.sqrt(a);n={...n,mass:o.mass,stiffness:a,damping:s}}else{let e=d({...t,velocity:0});n={...n,...e,mass:o.mass},n.isResolvedFromDuration=!0}return n}function g(e=o.visualDuration,t=o.bounce){let a=typeof e==`object`?e:{visualDuration:e,keyframes:[0,1],bounce:t},{restSpeed:c,restDelta:l}=a,u=a.keyframes[0],d=a.keyframes[a.keyframes.length-1],f={done:!1,value:u},{stiffness:p,damping:m,mass:g,duration:_,velocity:v,isResolvedFromDuration:y}=h({...a,velocity:-n.millisecondsToSeconds(a.velocity||0)}),b=v||0,x=m/(2*Math.sqrt(p*g)),S=d-u,C=n.millisecondsToSeconds(Math.sqrt(p/g)),w=Math.abs(S)<5;c||=w?o.restSpeed.granular:o.restSpeed.default,l||=w?o.restDelta.granular:o.restDelta.default;let T,E,D,O,k,A;if(x<1)D=s(C,x),O=(b+x*C*S)/D,T=e=>{let t=Math.exp(-x*C*e);return d-t*(O*Math.sin(D*e)+S*Math.cos(D*e))},k=x*C*O+S*D,A=x*C*S-O*D,E=e=>Math.exp(-x*C*e)*(k*Math.sin(D*e)+A*Math.cos(D*e));else if(x===1){T=e=>d-Math.exp(-C*e)*(S+(b+C*S)*e);let e=b+C*S;E=t=>Math.exp(-C*t)*(C*e*t-b)}else{let e=C*Math.sqrt(x*x-1);T=t=>{let n=Math.exp(-x*C*t),r=Math.min(e*t,300);return d-n*((b+x*C*S)*Math.sinh(r)+e*S*Math.cosh(r))/e};let t=(b+x*C*S)/e,n=x*C*t-S*e,r=x*C*S-t*e;E=t=>{let i=Math.exp(-x*C*t),a=Math.min(e*t,300);return i*(n*Math.sinh(a)+r*Math.cosh(a))}}let j={calculatedDuration:y&&_||null,velocity:e=>n.secondsToMilliseconds(E(e)),next:e=>{if(!y&&x<1){let t=Math.exp(-x*C*e),r=Math.sin(D*e),i=Math.cos(D*e),a=d-t*(O*r+S*i),o=n.secondsToMilliseconds(t*(k*r+A*i));return f.done=Math.abs(o)<=c&&Math.abs(d-a)<=l,f.value=f.done?d:a,f}let t=T(e);if(y)f.done=e>=_;else{let r=n.secondsToMilliseconds(E(e));f.done=Math.abs(r)<=c&&Math.abs(d-t)<=l}return f.value=f.done?d:t,f},toString:()=>{let e=Math.min(i.calcGeneratorDuration(j),i.maxGeneratorDuration),t=r.generateLinearEasing(t=>j.next(e*t).value,e,30);return e+`ms `+t},toTransition:()=>{}};return j}g.applyToOptions=e=>{let t=a.createGeneratorEasing(e,100,g);return e.ease=t.ease,e.duration=n.secondsToMilliseconds(t.duration),e.type=`keyframes`,e},exports.spring=g;
+//# sourceMappingURL=spring.cjs.js.map