@auronui/vue 1.0.0

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

@@ -0,0 +1,83 @@
+import { spring } from "./spring.js";
+import { getGeneratorVelocity } from "./utils/velocity.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/inertia.mjs
+function inertia({ keyframes, velocity = 0, power = .8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = .5, restSpeed }) {
+	const origin = keyframes[0];
+	const state = {
+		done: false,
+		value: origin
+	};
+	const isOutOfBounds = (v) => min !== void 0 && v < min || max !== void 0 && v > max;
+	const nearestBoundary = (v) => {
+		if (min === void 0) return max;
+		if (max === void 0) return min;
+		return Math.abs(min - v) < Math.abs(max - v) ? min : max;
+	};
+	let amplitude = power * velocity;
+	const ideal = origin + amplitude;
+	const target = modifyTarget === void 0 ? ideal : modifyTarget(ideal);
+	/**
+	* If the target has changed we need to re-calculate the amplitude, otherwise
+	* the animation will start from the wrong position.
+	*/
+	if (target !== ideal) amplitude = target - origin;
+	const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);
+	const calcLatest = (t) => target + calcDelta(t);
+	const applyFriction = (t) => {
+		const delta = calcDelta(t);
+		const latest = calcLatest(t);
+		state.done = Math.abs(delta) <= restDelta;
+		state.value = state.done ? target : latest;
+	};
+	/**
+	* Ideally this would resolve for t in a stateless way, we could
+	* do that by always precalculating the animation but as we know
+	* this will be done anyway we can assume that spring will
+	* be discovered during that.
+	*/
+	let timeReachedBoundary;
+	let spring$1;
+	const checkCatchBoundary = (t) => {
+		if (!isOutOfBounds(state.value)) return;
+		timeReachedBoundary = t;
+		spring$1 = spring({
+			keyframes: [state.value, nearestBoundary(state.value)],
+			velocity: getGeneratorVelocity(calcLatest, t, state.value),
+			damping: bounceDamping,
+			stiffness: bounceStiffness,
+			restDelta,
+			restSpeed
+		});
+	};
+	checkCatchBoundary(0);
+	return {
+		calculatedDuration: null,
+		next: (t) => {
+			/**
+			* We need to resolve the friction to figure out if we need a
+			* spring but we don't want to do this twice per frame. So here
+			* we flag if we updated for this frame and later if we did
+			* we can skip doing it again.
+			*/
+			let hasUpdatedFrame = false;
+			if (!spring$1 && timeReachedBoundary === void 0) {
+				hasUpdatedFrame = true;
+				applyFriction(t);
+				checkCatchBoundary(t);
+			}
+			/**
+			* If we have a spring and the provided t is beyond the moment the friction
+			* animation crossed the min/max boundary, use the spring.
+			*/
+			if (timeReachedBoundary !== void 0 && t >= timeReachedBoundary) return spring$1.next(t - timeReachedBoundary);
+			else {
+				!hasUpdatedFrame && applyFriction(t);
+				return state;
+			}
+		}
+	};
+}
+//#endregion
+export { inertia };
+
+//# sourceMappingURL=inertia.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/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,QAAQ,EAAE,WAAW,WAAW,GAAK,QAAQ,IAAK,eAAe,KAAK,gBAAgB,IAAI,kBAAkB,KAAK,cAAc,KAAK,KAAK,YAAY,IAAK,aAAc;CAC7K,MAAM,SAAS,UAAU;CACzB,MAAM,QAAQ;EACV,MAAM;EACN,OAAO;EACV;CACD,MAAM,iBAAiB,MAAO,QAAQ,KAAA,KAAa,IAAI,OAAS,QAAQ,KAAA,KAAa,IAAI;CACzF,MAAM,mBAAmB,MAAM;AAC3B,MAAI,QAAQ,KAAA,EACR,QAAO;AACX,MAAI,QAAQ,KAAA,EACR,QAAO;AACX,SAAO,KAAK,IAAI,MAAM,EAAE,GAAG,KAAK,IAAI,MAAM,EAAE,GAAG,MAAM;;CAEzD,IAAI,YAAY,QAAQ;CACxB,MAAM,QAAQ,SAAS;CACvB,MAAM,SAAS,iBAAiB,KAAA,IAAY,QAAQ,aAAa,MAAM;;;;;AAKvE,KAAI,WAAW,MACX,aAAY,SAAS;CACzB,MAAM,aAAa,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,IAAI,aAAa;CACjE,MAAM,cAAc,MAAM,SAAS,UAAU,EAAE;CAC/C,MAAM,iBAAiB,MAAM;EACzB,MAAM,QAAQ,UAAU,EAAE;EAC1B,MAAM,SAAS,WAAW,EAAE;AAC5B,QAAM,OAAO,KAAK,IAAI,MAAM,IAAI;AAChC,QAAM,QAAQ,MAAM,OAAO,SAAS;;;;;;;;CAQxC,IAAI;CACJ,IAAI;CACJ,MAAM,sBAAsB,MAAM;AAC9B,MAAI,CAAC,cAAc,MAAM,MAAM,CAC3B;AACJ,wBAAsB;AACtB,aAAW,OAAO;GACd,WAAW,CAAC,MAAM,OAAO,gBAAgB,MAAM,MAAM,CAAC;GACtD,UAAU,qBAAqB,YAAY,GAAG,MAAM,MAAM;GAC1D,SAAS;GACT,WAAW;GACX;GACA;GACH,CAAC;;AAEN,oBAAmB,EAAE;AACrB,QAAO;EACH,oBAAoB;EACpB,OAAO,MAAM;;;;;;;GAOT,IAAI,kBAAkB;AACtB,OAAI,CAAC,YAAY,wBAAwB,KAAA,GAAW;AAChD,sBAAkB;AAClB,kBAAc,EAAE;AAChB,uBAAmB,EAAE;;;;;;AAMzB,OAAI,wBAAwB,KAAA,KAAa,KAAK,oBAC1C,QAAO,SAAS,KAAK,IAAI,oBAAoB;QAE5C;AACD,KAAC,mBAAmB,cAAc,EAAE;AACpC,WAAO;;;EAGlB"}

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

@@ -0,0 +1,38 @@
+import { easeInOut } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/ease.js";
+import { isEasingArray } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/utils/is-easing-array.js";
+import { easingDefinitionToFunction } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/easing/utils/map.js";
+import { interpolate } from "../../utils/interpolate.js";
+import { defaultOffset } from "../keyframes/offsets/default.js";
+import { convertOffsetToTimes } from "../keyframes/offsets/time.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs
+function defaultEasing(values, easing) {
+	return values.map(() => easing || easeInOut).splice(0, values.length - 1);
+}
+function keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut" }) {
+	/**
+	* Easing functions can be externally defined as strings. Here we convert them
+	* into actual functions.
+	*/
+	const easingFunctions = isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);
+	/**
+	* This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
+	* to reduce GC during animation.
+	*/
+	const state = {
+		done: false,
+		value: keyframeValues[0]
+	};
+	const mapTimeToKeyframe = interpolate(convertOffsetToTimes(times && times.length === keyframeValues.length ? times : defaultOffset(keyframeValues), duration), keyframeValues, { ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions) });
+	return {
+		calculatedDuration: duration,
+		next: (t) => {
+			state.value = mapTimeToKeyframe(t);
+			state.done = t >= duration;
+			return state;
+		}
+	};
+}
+//#endregion
+export { keyframes };
+
+//# sourceMappingURL=keyframes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyframes.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/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,cAAc,QAAQ,QAAQ;AACnC,QAAO,OAAO,UAAU,UAAU,UAAU,CAAC,OAAO,GAAG,OAAO,SAAS,EAAE;;AAE7E,SAAS,UAAU,EAAE,WAAW,KAAK,WAAW,gBAAgB,OAAO,OAAO,eAAgB;;;;;CAK1F,MAAM,kBAAkB,cAAc,KAAK,GACrC,KAAK,IAAI,2BAA2B,GACpC,2BAA2B,KAAK;;;;;CAKtC,MAAM,QAAQ;EACV,MAAM;EACN,OAAO,eAAe;EACzB;CAUD,MAAM,oBAAoB,YANJ,qBAGtB,SAAS,MAAM,WAAW,eAAe,SACnC,QACA,cAAc,eAAe,EAAE,SAAS,EACO,gBAAgB,EACjE,MAAM,MAAM,QAAQ,gBAAgB,GAC9B,kBACA,cAAc,gBAAgB,gBAAgB,EACvD,CAAC;AACF,QAAO;EACH,oBAAoB;EACpB,OAAO,MAAM;AACT,SAAM,QAAQ,kBAAkB,EAAE;AAClC,SAAM,OAAO,KAAK;AAClB,UAAO;;EAEd"}

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

@@ -0,0 +1,266 @@
+import { clamp } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/clamp.js";
+import { warning } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/errors.js";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/time-conversion.js";
+import { generateLinearEasing } from "../waapi/utils/linear.js";
+import { calcGeneratorDuration, maxGeneratorDuration } from "./utils/calc-duration.js";
+import { createGeneratorEasing } from "./utils/create-generator-easing.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/spring.mjs
+var springDefaults = {
+	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 calcAngularFreq(undampedFreq, dampingRatio) {
+	return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
+}
+var rootIterations = 12;
+function approximateRoot(envelope, derivative, initialGuess) {
+	let result = initialGuess;
+	for (let i = 1; i < rootIterations; i++) result = result - envelope(result) / derivative(result);
+	return result;
+}
+/**
+* This is ported from the Framer implementation of duration-based spring resolution.
+*/
+var safeMin = .001;
+function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
+	let envelope;
+	let derivative;
+	warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+	let dampingRatio = 1 - bounce;
+	/**
+	* Restrict dampingRatio and duration to within acceptable ranges.
+	*/
+	dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
+	duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));
+	if (dampingRatio < 1) {
+		/**
+		* Underdamped spring
+		*/
+		envelope = (undampedFreq) => {
+			const exponentialDecay = undampedFreq * dampingRatio;
+			const delta = exponentialDecay * duration;
+			const a = exponentialDecay - velocity;
+			const b = calcAngularFreq(undampedFreq, dampingRatio);
+			const c = Math.exp(-delta);
+			return safeMin - a / b * c;
+		};
+		derivative = (undampedFreq) => {
+			const delta = undampedFreq * dampingRatio * duration;
+			const d = delta * velocity + velocity;
+			const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;
+			const f = Math.exp(-delta);
+			const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);
+			return (-envelope(undampedFreq) + safeMin > 0 ? -1 : 1) * ((d - e) * f) / g;
+		};
+	} else {
+		/**
+		* Critically-damped spring
+		*/
+		envelope = (undampedFreq) => {
+			const a = Math.exp(-undampedFreq * duration);
+			const b = (undampedFreq - velocity) * duration + 1;
+			return -safeMin + a * b;
+		};
+		derivative = (undampedFreq) => {
+			return Math.exp(-undampedFreq * duration) * ((velocity - undampedFreq) * (duration * duration));
+		};
+	}
+	const initialGuess = 5 / duration;
+	const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
+	duration = secondsToMilliseconds(duration);
+	if (isNaN(undampedFreq)) return {
+		stiffness: springDefaults.stiffness,
+		damping: springDefaults.damping,
+		duration
+	};
+	else {
+		const stiffness = Math.pow(undampedFreq, 2) * mass;
+		return {
+			stiffness,
+			damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
+			duration
+		};
+	}
+}
+var durationKeys = ["duration", "bounce"];
+var physicsKeys = [
+	"stiffness",
+	"damping",
+	"mass"
+];
+function isSpringType(options, keys) {
+	return keys.some((key) => options[key] !== void 0);
+}
+function getSpringOptions(options) {
+	let springOptions = {
+		velocity: springDefaults.velocity,
+		stiffness: springDefaults.stiffness,
+		damping: springDefaults.damping,
+		mass: springDefaults.mass,
+		isResolvedFromDuration: false,
+		...options
+	};
+	if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {
+		springOptions.velocity = 0;
+		if (options.visualDuration) {
+			const visualDuration = options.visualDuration;
+			const root = 2 * Math.PI / (visualDuration * 1.2);
+			const stiffness = root * root;
+			const damping = 2 * clamp(.05, 1, 1 - (options.bounce || 0)) * Math.sqrt(stiffness);
+			springOptions = {
+				...springOptions,
+				mass: springDefaults.mass,
+				stiffness,
+				damping
+			};
+		} else {
+			const derived = findSpring({
+				...options,
+				velocity: 0
+			});
+			springOptions = {
+				...springOptions,
+				...derived,
+				mass: springDefaults.mass
+			};
+			springOptions.isResolvedFromDuration = true;
+		}
+	}
+	return springOptions;
+}
+function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
+	const options = typeof optionsOrVisualDuration !== "object" ? {
+		visualDuration: optionsOrVisualDuration,
+		keyframes: [0, 1],
+		bounce
+	} : optionsOrVisualDuration;
+	let { restSpeed, restDelta } = options;
+	const origin = options.keyframes[0];
+	const target = options.keyframes[options.keyframes.length - 1];
+	/**
+	* This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
+	* to reduce GC during animation.
+	*/
+	const state = {
+		done: false,
+		value: origin
+	};
+	const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
+		...options,
+		velocity: -millisecondsToSeconds(options.velocity || 0)
+	});
+	const initialVelocity = velocity || 0;
+	const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+	const initialDelta = target - origin;
+	const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
+	/**
+	* If we're working on a granular scale, use smaller defaults for determining
+	* when the spring is finished.
+	*
+	* These defaults have been selected emprically based on what strikes a good
+	* ratio between feeling good and finishing as soon as changes are imperceptible.
+	*/
+	const isGranularScale = Math.abs(initialDelta) < 5;
+	restSpeed || (restSpeed = isGranularScale ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default);
+	restDelta || (restDelta = isGranularScale ? springDefaults.restDelta.granular : springDefaults.restDelta.default);
+	let resolveSpring;
+	let resolveVelocity;
+	let angularFreq;
+	let A;
+	let sinCoeff;
+	let cosCoeff;
+	if (dampingRatio < 1) {
+		angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
+		A = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq;
+		resolveSpring = (t) => {
+			return target - Math.exp(-dampingRatio * undampedAngularFreq * t) * (A * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));
+		};
+		sinCoeff = dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;
+		cosCoeff = dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;
+		resolveVelocity = (t) => {
+			return Math.exp(-dampingRatio * undampedAngularFreq * t) * (sinCoeff * Math.sin(angularFreq * t) + cosCoeff * Math.cos(angularFreq * t));
+		};
+	} else if (dampingRatio === 1) {
+		resolveSpring = (t) => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);
+		const C = initialVelocity + undampedAngularFreq * initialDelta;
+		resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) * (undampedAngularFreq * C * t - initialVelocity);
+	} else {
+		const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
+		resolveSpring = (t) => {
+			const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+			const freqForT = Math.min(dampedAngularFreq * t, 300);
+			return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
+		};
+		const P = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / dampedAngularFreq;
+		const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;
+		const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;
+		resolveVelocity = (t) => {
+			const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+			const freqForT = Math.min(dampedAngularFreq * t, 300);
+			return envelope * (sinhCoeff * Math.sinh(freqForT) + coshCoeff * Math.cosh(freqForT));
+		};
+	}
+	const generator = {
+		calculatedDuration: isResolvedFromDuration ? duration || null : null,
+		velocity: (t) => secondsToMilliseconds(resolveVelocity(t)),
+		next: (t) => {
+			/**
+			* For underdamped physics springs we need both position and
+			* velocity each tick. Compute shared trig values once to avoid
+			* duplicate Math.exp/sin/cos calls on the hot path.
+			*/
+			if (!isResolvedFromDuration && dampingRatio < 1) {
+				const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+				const sin = Math.sin(angularFreq * t);
+				const cos = Math.cos(angularFreq * t);
+				const current = target - envelope * (A * sin + initialDelta * cos);
+				const currentVelocity = secondsToMilliseconds(envelope * (sinCoeff * sin + cosCoeff * cos));
+				state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current) <= restDelta;
+				state.value = state.done ? target : current;
+				return state;
+			}
+			const current = resolveSpring(t);
+			if (!isResolvedFromDuration) {
+				const currentVelocity = secondsToMilliseconds(resolveVelocity(t));
+				state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current) <= restDelta;
+			} else state.done = t >= duration;
+			state.value = state.done ? target : current;
+			return state;
+		},
+		toString: () => {
+			const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+			const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);
+			return calculatedDuration + "ms " + easing;
+		},
+		toTransition: () => {}
+	};
+	return generator;
+}
+spring.applyToOptions = (options) => {
+	const generatorOptions = createGeneratorEasing(options, 100, spring);
+	options.ease = generatorOptions.ease;
+	options.duration = secondsToMilliseconds(generatorOptions.duration);
+	options.type = "keyframes";
+	return options;
+};
+//#endregion
+export { spring };
+
+//# sourceMappingURL=spring.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spring.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/spring.mjs"],"sourcesContent":["import { millisecondsToSeconds, clamp, secondsToMilliseconds, warning } from 'motion-utils';\nimport { generateLinearEasing } from '../waapi/utils/linear.mjs';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './utils/calc-duration.mjs';\nimport { createGeneratorEasing } from './utils/create-generator-easing.mjs';\n\nconst springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\n/**\n * This is ported from the Framer implementation of duration-based spring resolution.\n */\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\", \"spring-duration-limit\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        // Time-defined springs should ignore inherited velocity.\n        // Velocity from interrupted animations can cause findSpring()\n        // to compute wildly different spring parameters, leading to\n        // massive oscillation on small-range animations.\n        springOptions.velocity = 0;\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring({ ...options, velocity: 0 });\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    let resolveVelocity;\n    // Underdamped coefficients, hoisted for use in the inlined next() hot path\n    let angularFreq;\n    let A;\n    let sinCoeff;\n    let cosCoeff;\n    if (dampingRatio < 1) {\n        angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        A =\n            (initialVelocity +\n                dampingRatio * undampedAngularFreq * initialDelta) /\n                angularFreq;\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (A * Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n        // Analytical derivative of underdamped spring (px/ms)\n        sinCoeff =\n            dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;\n        cosCoeff =\n            dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return envelope *\n                (sinCoeff * Math.sin(angularFreq * t) +\n                    cosCoeff * Math.cos(angularFreq * t));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n        // Analytical derivative of critically damped spring (px/ms)\n        const C = initialVelocity + undampedAngularFreq * initialDelta;\n        resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) *\n            (undampedAngularFreq * C * t - initialVelocity);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n        // Analytical derivative of overdamped spring (px/ms)\n        const P = (initialVelocity +\n            dampingRatio * undampedAngularFreq * initialDelta) /\n            dampedAngularFreq;\n        const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;\n        const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;\n        resolveVelocity = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return envelope *\n                (sinhCoeff * Math.sinh(freqForT) +\n                    coshCoeff * Math.cosh(freqForT));\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        velocity: (t) => secondsToMilliseconds(resolveVelocity(t)),\n        next: (t) => {\n            /**\n             * For underdamped physics springs we need both position and\n             * velocity each tick. Compute shared trig values once to avoid\n             * duplicate Math.exp/sin/cos calls on the hot path.\n             */\n            if (!isResolvedFromDuration && dampingRatio < 1) {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const sin = Math.sin(angularFreq * t);\n                const cos = Math.cos(angularFreq * t);\n                const current = target -\n                    envelope *\n                        (A * sin + initialDelta * cos);\n                const currentVelocity = secondsToMilliseconds(envelope *\n                    (sinCoeff * sin + cosCoeff * cos));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\n                state.value = state.done ? target : current;\n                return state;\n            }\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                const currentVelocity = secondsToMilliseconds(resolveVelocity(t));\n                state.done =\n                    Math.abs(currentVelocity) <= restSpeed &&\n                        Math.abs(target - current) <= restDelta;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n        toTransition: () => { },\n    };\n    return generator;\n}\nspring.applyToOptions = (options) => {\n    const generatorOptions = createGeneratorEasing(options, 100, spring);\n    options.ease = generatorOptions.ease;\n    options.duration = secondsToMilliseconds(generatorOptions.duration);\n    options.type = \"keyframes\";\n    return options;\n};\n\nexport { spring };\n//# sourceMappingURL=spring.mjs.map\n"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -0,0 +1,20 @@
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs
+/**
+* Implement a practical max duration for keyframe generation
+* to prevent infinite loops
+*/
+var maxGeneratorDuration = 2e4;
+function calcGeneratorDuration(generator) {
+	let duration = 0;
+	const timeStep = 50;
+	let state = generator.next(duration);
+	while (!state.done && duration < 2e4) {
+		duration += timeStep;
+		state = generator.next(duration);
+	}
+	return duration >= 2e4 ? Infinity : duration;
+}
+//#endregion
+export { calcGeneratorDuration, maxGeneratorDuration };
+
+//# sourceMappingURL=calc-duration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calc-duration.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs"],"sourcesContent":["/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n//# sourceMappingURL=calc-duration.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAIA,IAAM,uBAAuB;AAC7B,SAAS,sBAAsB,WAAW;CACtC,IAAI,WAAW;CACf,MAAM,WAAW;CACjB,IAAI,QAAQ,UAAU,KAAK,SAAS;AACpC,QAAO,CAAC,MAAM,QAAQ,WAAA,KAAiC;AACnD,cAAY;AACZ,UAAQ,UAAU,KAAK,SAAS;;AAEpC,QAAO,YAAA,MAAmC,WAAW"}

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

@@ -0,0 +1,24 @@
+import { millisecondsToSeconds } from "../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/time-conversion.js";
+import { calcGeneratorDuration, maxGeneratorDuration } from "./calc-duration.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs
+/**
+* Create a progress => progress easing function from a generator.
+*/
+function createGeneratorEasing(options, scale = 100, createGenerator) {
+	const generator = createGenerator({
+		...options,
+		keyframes: [0, scale]
+	});
+	const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+	return {
+		type: "keyframes",
+		ease: (progress) => {
+			return generator.next(duration * progress).value / scale;
+		},
+		duration: millisecondsToSeconds(duration)
+	};
+}
+//#endregion
+export { createGeneratorEasing };
+
+//# sourceMappingURL=create-generator-easing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-generator-easing.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs"],"sourcesContent":["import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n//# sourceMappingURL=create-generator-easing.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAMA,SAAS,sBAAsB,SAAS,QAAQ,KAAK,iBAAiB;CAClE,MAAM,YAAY,gBAAgB;EAAE,GAAG;EAAS,WAAW,CAAC,GAAG,MAAM;EAAE,CAAC;CACxE,MAAM,WAAW,KAAK,IAAI,sBAAsB,UAAU,EAAE,qBAAqB;AACjF,QAAO;EACH,MAAM;EACN,OAAO,aAAa;AAChB,UAAO,UAAU,KAAK,WAAW,SAAS,CAAC,QAAQ;;EAEvD,UAAU,sBAAsB,SAAS;EAC5C"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-generator.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs"],"sourcesContent":["function isGenerator(type) {\n    return typeof type === \"function\" && \"applyToOptions\" in type;\n}\n\nexport { isGenerator };\n//# sourceMappingURL=is-generator.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAS,YAAY,MAAM;AACvB,QAAO,OAAO,SAAS,cAAc,oBAAoB"}

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

@@ -0,0 +1,11 @@
+import { velocityPerSecond } from "../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/velocity-per-second.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs
+var velocitySampleDuration = 5;
+function getGeneratorVelocity(resolveValue, t, current) {
+	const prevT = Math.max(t - velocitySampleDuration, 0);
+	return velocityPerSecond(current - resolveValue(prevT), t - prevT);
+}
+//#endregion
+export { getGeneratorVelocity };
+
+//# sourceMappingURL=velocity.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"velocity.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs"],"sourcesContent":["import { velocityPerSecond } from 'motion-utils';\n\nconst velocitySampleDuration = 5; // ms\nfunction getGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { getGeneratorVelocity };\n//# sourceMappingURL=velocity.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;AAEA,IAAM,yBAAyB;AAC/B,SAAS,qBAAqB,cAAc,GAAG,SAAS;CACpD,MAAM,QAAQ,KAAK,IAAI,IAAI,wBAAwB,EAAE;AACrD,QAAO,kBAAkB,UAAU,aAAa,MAAM,EAAE,IAAI,MAAM"}

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

@@ -0,0 +1,95 @@
+import { MotionGlobalConfig } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/global-config.js";
+import { secondsToMilliseconds } from "../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/time-conversion.js";
+import { frame } from "../../frameloop/frame.js";
+import { getFinalKeyframe } from "../keyframes/get-final.js";
+import { JSAnimation } from "../JSAnimation.js";
+import { makeAnimationInstant } from "../utils/make-animation-instant.js";
+import { AsyncMotionValueAnimation } from "../AsyncMotionValueAnimation.js";
+import { getDefaultTransition } from "../utils/default-transitions.js";
+import { getValueTransition } from "../utils/get-value-transition.js";
+import { isTransitionDefined } from "../utils/is-transition-defined.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs
+var animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
+	const valueTransition = getValueTransition(transition, name) || {};
+	/**
+	* Most transition values are currently completely overwritten by value-specific
+	* transitions. In the future it'd be nicer to blend these transitions. But for now
+	* delay actually does inherit from the root transition if not value-specific.
+	*/
+	const delay = valueTransition.delay || transition.delay || 0;
+	/**
+	* Elapsed isn't a public transition option but can be passed through from
+	* optimized appear effects in milliseconds.
+	*/
+	let { elapsed = 0 } = transition;
+	elapsed = elapsed - secondsToMilliseconds(delay);
+	const options = {
+		keyframes: Array.isArray(target) ? target : [null, target],
+		ease: "easeOut",
+		velocity: value.getVelocity(),
+		...valueTransition,
+		delay: -elapsed,
+		onUpdate: (v) => {
+			value.set(v);
+			valueTransition.onUpdate && valueTransition.onUpdate(v);
+		},
+		onComplete: () => {
+			onComplete();
+			valueTransition.onComplete && valueTransition.onComplete();
+		},
+		name,
+		motionValue: value,
+		element: isHandoff ? void 0 : element
+	};
+	/**
+	* If there's no transition defined for this value, we can generate
+	* unique transition settings for this value.
+	*/
+	if (!isTransitionDefined(valueTransition)) Object.assign(options, getDefaultTransition(name, options));
+	/**
+	* Both WAAPI and our internal animation functions use durations
+	* as defined by milliseconds, while our external API defines them
+	* as seconds.
+	*/
+	options.duration && (options.duration = secondsToMilliseconds(options.duration));
+	options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));
+	/**
+	* Support deprecated way to set initial value. Prefer keyframe syntax.
+	*/
+	if (options.from !== void 0) options.keyframes[0] = options.from;
+	let shouldSkip = false;
+	if (options.type === false || options.duration === 0 && !options.repeatDelay) {
+		makeAnimationInstant(options);
+		if (options.delay === 0) shouldSkip = true;
+	}
+	if (MotionGlobalConfig.instantAnimations || MotionGlobalConfig.skipAnimations || element?.shouldSkipAnimations) {
+		shouldSkip = true;
+		makeAnimationInstant(options);
+		options.delay = 0;
+	}
+	/**
+	* If the transition type or easing has been explicitly set by the user
+	* then we don't want to allow flattening the animation.
+	*/
+	options.allowFlatten = !valueTransition.type && !valueTransition.ease;
+	/**
+	* If we can or must skip creating the animation, and apply only
+	* the final keyframe, do so. We also check once keyframes are resolved but
+	* this early check prevents the need to create an animation at all.
+	*/
+	if (shouldSkip && !isHandoff && value.get() !== void 0) {
+		const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);
+		if (finalKeyframe !== void 0) {
+			frame.update(() => {
+				options.onUpdate(finalKeyframe);
+				options.onComplete();
+			});
+			return;
+		}
+	}
+	return valueTransition.isSync ? new JSAnimation(options) : new AsyncMotionValueAnimation(options);
+};
+//#endregion
+export { animateMotionValue };
+
+//# sourceMappingURL=motion-value.js.map