@auronui/vue 1.0.0

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/JSAnimation.js

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

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/JSAnimation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSAnimation.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/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 { activeAnimations } from '../stats/animation-count.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        activeAnimations.mainThread++;\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        activeAnimations.mainThread--;\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/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/NativeAnimation.js

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

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

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

@@ -0,0 +1,85 @@
+import { clamp } from "../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/clamp.js";
+import { time } from "../frameloop/sync-time.js";
+import { replaceTransitionType } from "./utils/replace-transition-type.js";
+import { JSAnimation } from "./JSAnimation.js";
+import { setStyle } from "../render/dom/style-set.js";
+import { NativeAnimation } from "./NativeAnimation.js";
+import { replaceStringEasing } from "./waapi/utils/unsupported-easing.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs
+/**
+* 10ms is chosen here as it strikes a balance between smooth
+* results (more than one keyframe per frame at 60fps) and
+* keyframe quantity.
+*/
+var sampleDelta = 10;
+var NativeAnimationExtended = class extends NativeAnimation {
+	constructor(options) {
+		/**
+		* The base NativeAnimation function only supports a subset
+		* of Motion easings, and WAAPI also only supports some
+		* easing functions via string/cubic-bezier definitions.
+		*
+		* This function replaces those unsupported easing functions
+		* with a JS easing function. This will later get compiled
+		* to a linear() easing function.
+		*/
+		replaceStringEasing(options);
+		/**
+		* Ensure we replace the transition type with a generator function
+		* before passing to WAAPI.
+		*
+		* TODO: Does this have a better home? It could be shared with
+		* JSAnimation.
+		*/
+		replaceTransitionType(options);
+		super(options);
+		/**
+		* Only set startTime when the animation should autoplay.
+		* Setting startTime on a paused WAAPI animation unpauses it
+		* (per the WAAPI spec), which breaks autoplay: false.
+		*/
+		if (options.startTime !== void 0 && options.autoplay !== false) this.startTime = options.startTime;
+		this.options = options;
+	}
+	/**
+	* WAAPI doesn't natively have any interruption capabilities.
+	*
+	* Rather than read committed styles back out of the DOM, we can
+	* create a renderless JS animation and sample it twice to calculate
+	* its current value, "previous" value, and therefore allow
+	* Motion to calculate velocity for any subsequent animation.
+	*/
+	updateMotionValue(value) {
+		const { motionValue, onUpdate, onComplete, element, ...options } = this.options;
+		if (!motionValue) return;
+		if (value !== void 0) {
+			motionValue.set(value);
+			return;
+		}
+		const sampleAnimation = new JSAnimation({
+			...options,
+			autoplay: false
+		});
+		/**
+		* Use wall-clock elapsed time for sampling.
+		* Under CPU load, WAAPI's currentTime may not reflect actual
+		* elapsed time, causing incorrect sampling and visual jumps.
+		*/
+		const sampleTime = Math.max(sampleDelta, time.now() - this.startTime);
+		const delta = clamp(0, sampleDelta, sampleTime - sampleDelta);
+		const current = sampleAnimation.sample(sampleTime).value;
+		/**
+		* Write the estimated value to inline style so it persists
+		* after cancel(), covering the async gap before the next
+		* animation starts.
+		*/
+		const { name } = this.options;
+		if (element && name) setStyle(element, name, current);
+		motionValue.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current, delta);
+		sampleAnimation.stop();
+	}
+};
+//#endregion
+export { NativeAnimationExtended };
+
+//# sourceMappingURL=NativeAnimationExtended.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAnimationExtended.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/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,cAAc;AACpB,IAAM,0BAAN,cAAsC,gBAAgB;CAClD,YAAY,SAAS;;;;;;;;;;AAUjB,sBAAoB,QAAQ;;;;;;;;AAQ5B,wBAAsB,QAAQ;AAC9B,QAAM,QAAQ;;;;;;AAMd,MAAI,QAAQ,cAAc,KAAA,KAAa,QAAQ,aAAa,MACxD,MAAK,YAAY,QAAQ;AAE7B,OAAK,UAAU;;;;;;;;;;CAUnB,kBAAkB,OAAO;EACrB,MAAM,EAAE,aAAa,UAAU,YAAY,SAAS,GAAG,YAAY,KAAK;AACxE,MAAI,CAAC,YACD;AACJ,MAAI,UAAU,KAAA,GAAW;AACrB,eAAY,IAAI,MAAM;AACtB;;EAEJ,MAAM,kBAAkB,IAAI,YAAY;GACpC,GAAG;GACH,UAAU;GACb,CAAC;;;;;;EAMF,MAAM,aAAa,KAAK,IAAI,aAAa,KAAK,KAAK,GAAG,KAAK,UAAU;EACrE,MAAM,QAAQ,MAAM,GAAG,aAAa,aAAa,YAAY;EAC7D,MAAM,UAAU,gBAAgB,OAAO,WAAW,CAAC;;;;;;EAMnD,MAAM,EAAE,SAAS,KAAK;AACtB,MAAI,WAAW,KACX,UAAS,SAAS,MAAM,QAAQ;AACpC,cAAY,gBAAgB,gBAAgB,OAAO,KAAK,IAAI,GAAG,aAAa,MAAM,CAAC,CAAC,OAAO,SAAS,MAAM;AAC1G,kBAAgB,MAAM"}

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

@@ -0,0 +1,13 @@
+import { animateMotionValue } from "../interfaces/motion-value.js";
+import { motionValue } from "../../value/index.js";
+import { isMotionValue } from "../../value/utils/is-motion-value.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/animate/single-value.mjs
+function animateSingleValue(value, keyframes, options) {
+	const motionValue$1 = isMotionValue(value) ? value : motionValue(value);
+	motionValue$1.start(animateMotionValue("", motionValue$1, keyframes, options));
+	return motionValue$1.animation;
+}
+//#endregion
+export { animateSingleValue };
+
+//# sourceMappingURL=single-value.js.map

package/dist/node_modules/.pnpm/motion-dom@12.38.0/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/.pnpm/motion-dom@12.38.0/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,mBAAmB,OAAO,WAAW,SAAS;CACnD,MAAM,gBAAgB,cAAc,MAAM,GAAG,QAAQ,YAAY,MAAM;AACvE,eAAc,MAAM,mBAAmB,IAAI,eAAe,WAAW,QAAQ,CAAC;AAC9E,QAAO,cAAc"}

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

@@ -0,0 +1,15 @@
+import { cancelFrame, frame, frameData } from "../../frameloop/frame.js";
+import { time } from "../../frameloop/sync-time.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/drivers/frame.mjs
+var frameloopDriver = (update) => {
+	const passTimestamp = ({ timestamp }) => update(timestamp);
+	return {
+		start: (keepAlive = true) => frame.update(passTimestamp, keepAlive),
+		stop: () => cancelFrame(passTimestamp),
+		now: () => frameData.isProcessing ? frameData.timestamp : time.now()
+	};
+};
+//#endregion
+export { frameloopDriver };
+
+//# sourceMappingURL=frame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/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,mBAAmB,WAAW;CAChC,MAAM,iBAAiB,EAAE,gBAAgB,OAAO,UAAU;AAC1D,QAAO;EACH,QAAQ,YAAY,SAAS,MAAM,OAAO,eAAe,UAAU;EACnE,YAAY,YAAY,cAAc;EAKtC,WAAY,UAAU,eAAe,UAAU,YAAY,KAAK,KAAK;EACxE"}