@auronui/vue 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"motion-value.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["import { secondsToMilliseconds, MotionGlobalConfig } from 'motion-utils';\nimport { AsyncMotionValueAnimation } from '../AsyncMotionValueAnimation.mjs';\nimport { JSAnimation } from '../JSAnimation.mjs';\nimport { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { makeAnimationInstant } from '../utils/make-animation-instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getFinalKeyframe } from '../keyframes/get-final.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    const options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unique transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        Object.assign(options, getDefaultTransition(name, options));\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    options.duration && (options.duration = secondsToMilliseconds(options.duration));\n    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));\n    /**\n     * Support deprecated way to set initial value. Prefer keyframe syntax.\n     */\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        makeAnimationInstant(options);\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (MotionGlobalConfig.instantAnimations ||\n        MotionGlobalConfig.skipAnimations ||\n        element?.shouldSkipAnimations) {\n        shouldSkip = true;\n        makeAnimationInstant(options);\n        options.delay = 0;\n    }\n    /**\n     * If the transition type or easing has been explicitly set by the user\n     * then we don't want to allow flattening the animation.\n     */\n    options.allowFlatten = !valueTransition.type && !valueTransition.ease;\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            return;\n        }\n    }\n    return valueTransition.isSync\n        ? new JSAnimation(options)\n        : new AsyncMotionValueAnimation(options);\n};\n\nexport { animateMotionValue };\n//# sourceMappingURL=motion-value.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;AAUA,IAAM,sBAAsB,MAAM,OAAO,QAAQ,aAAa,EAAE,EAAE,SAAS,eAAe,eAAe;CACrG,MAAM,kBAAkB,mBAAmB,YAAY,KAAK,IAAI,EAAE;;;;;;CAMlE,MAAM,QAAQ,gBAAgB,SAAS,WAAW,SAAS;;;;;CAK3D,IAAI,EAAE,UAAU,MAAM;AACtB,WAAU,UAAU,sBAAsB,MAAM;CAChD,MAAM,UAAU;EACZ,WAAW,MAAM,QAAQ,OAAO,GAAG,SAAS,CAAC,MAAM,OAAO;EAC1D,MAAM;EACN,UAAU,MAAM,aAAa;EAC7B,GAAG;EACH,OAAO,CAAC;EACR,WAAW,MAAM;AACb,SAAM,IAAI,EAAE;AACZ,mBAAgB,YAAY,gBAAgB,SAAS,EAAE;;EAE3D,kBAAkB;AACd,eAAY;AACZ,mBAAgB,cAAc,gBAAgB,YAAY;;EAE9D;EACA,aAAa;EACb,SAAS,YAAY,KAAA,IAAY;EACpC;;;;;AAKD,KAAI,CAAC,oBAAoB,gBAAgB,CACrC,QAAO,OAAO,SAAS,qBAAqB,MAAM,QAAQ,CAAC;;;;;;AAO/D,SAAQ,aAAa,QAAQ,WAAW,sBAAsB,QAAQ,SAAS;AAC/E,SAAQ,gBAAgB,QAAQ,cAAc,sBAAsB,QAAQ,YAAY;;;;AAIxF,KAAI,QAAQ,SAAS,KAAA,EACjB,SAAQ,UAAU,KAAK,QAAQ;CAEnC,IAAI,aAAa;AACjB,KAAI,QAAQ,SAAS,SAChB,QAAQ,aAAa,KAAK,CAAC,QAAQ,aAAc;AAClD,uBAAqB,QAAQ;AAC7B,MAAI,QAAQ,UAAU,EAClB,cAAa;;AAGrB,KAAI,mBAAmB,qBACnB,mBAAmB,kBACnB,SAAS,sBAAsB;AAC/B,eAAa;AACb,uBAAqB,QAAQ;AAC7B,UAAQ,QAAQ;;;;;;AAMpB,SAAQ,eAAe,CAAC,gBAAgB,QAAQ,CAAC,gBAAgB;;;;;;AAMjE,KAAI,cAAc,CAAC,aAAa,MAAM,KAAK,KAAK,KAAA,GAAW;EACvD,MAAM,gBAAgB,iBAAiB,QAAQ,WAAW,gBAAgB;AAC1E,MAAI,kBAAkB,KAAA,GAAW;AAC7B,SAAM,aAAa;AACf,YAAQ,SAAS,cAAc;AAC/B,YAAQ,YAAY;KACtB;AACF;;;AAGR,QAAO,gBAAgB,SACjB,IAAI,YAAY,QAAQ,GACxB,IAAI,0BAA0B,QAAQ"}

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.js

@@ -0,0 +1,80 @@
+import { frame } from "../../frameloop/frame.js";
+import { resolveTransition } from "../utils/resolve-transition.js";
+import { getValueTransition } from "../utils/get-value-transition.js";
+import { animateMotionValue } from "./motion-value.js";
+import { positionalKeys } from "../../render/utils/keys-position.js";
+import { setTarget } from "../../render/utils/setters.js";
+import { addValueToWillChange } from "../../value/will-change/add-will-change.js";
+import { getOptimisedAppearId } from "../optimized-appear/get-appear-id.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs
+/**
+* Decide whether we should block this animation. Previously, we achieved this
+* just by checking whether the key was listed in protectedKeys, but this
+* posed problems if an animation was triggered by afterChildren and protectedKeys
+* had been set to true in the meantime.
+*/
+function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
+	const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
+	needsAnimating[key] = false;
+	return shouldBlock;
+}
+function animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {
+	let { transition, transitionEnd, ...target } = targetAndTransition;
+	const defaultTransition = visualElement.getDefaultTransition();
+	transition = transition ? resolveTransition(transition, defaultTransition) : defaultTransition;
+	const reduceMotion = transition?.reduceMotion;
+	if (transitionOverride) transition = transitionOverride;
+	const animations = [];
+	const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];
+	for (const key in target) {
+		const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);
+		const valueTarget = target[key];
+		if (valueTarget === void 0 || animationTypeState && shouldBlockAnimation(animationTypeState, key)) continue;
+		const valueTransition = {
+			delay,
+			...getValueTransition(transition || {}, key)
+		};
+		/**
+		* If the value is already at the defined target, skip the animation.
+		* We still re-assert the value via frame.update to take precedence
+		* over any stale transitionEnd callbacks from previous animations.
+		*/
+		const currentValue = value.get();
+		if (currentValue !== void 0 && !value.isAnimating() && !Array.isArray(valueTarget) && valueTarget === currentValue && !valueTransition.velocity) {
+			frame.update(() => value.set(valueTarget));
+			continue;
+		}
+		/**
+		* If this is the first time a value is being animated, check
+		* to see if we're handling off from an existing animation.
+		*/
+		let isHandoff = false;
+		if (window.MotionHandoffAnimation) {
+			const appearId = getOptimisedAppearId(visualElement);
+			if (appearId) {
+				const startTime = window.MotionHandoffAnimation(appearId, key, frame);
+				if (startTime !== null) {
+					valueTransition.startTime = startTime;
+					isHandoff = true;
+				}
+			}
+		}
+		addValueToWillChange(visualElement, key);
+		const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;
+		value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key) ? { type: false } : valueTransition, visualElement, isHandoff));
+		const animation = value.animation;
+		if (animation) animations.push(animation);
+	}
+	if (transitionEnd) {
+		const applyTransitionEnd = () => frame.update(() => {
+			transitionEnd && setTarget(visualElement, transitionEnd);
+		});
+		if (animations.length) Promise.all(animations).then(applyTransitionEnd);
+		else applyTransitionEnd();
+	}
+	return animations;
+}
+//#endregion
+export { animateTarget };
+
+//# sourceMappingURL=visual-element-target.js.map

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-element-target.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs"],"sourcesContent":["import { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { resolveTransition } from '../utils/resolve-transition.mjs';\nimport { positionalKeys } from '../../render/utils/keys-position.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { addValueToWillChange } from '../../value/will-change/add-will-change.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    let { transition, transitionEnd, ...target } = targetAndTransition;\n    const defaultTransition = visualElement.getDefaultTransition();\n    transition = transition\n        ? resolveTransition(transition, defaultTransition)\n        : defaultTransition;\n    const reduceMotion = transition?.reduceMotion;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    for (const key in target) {\n        const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            ...getValueTransition(transition || {}, key),\n        };\n        /**\n         * If the value is already at the defined target, skip the animation.\n         * We still re-assert the value via frame.update to take precedence\n         * over any stale transitionEnd callbacks from previous animations.\n         */\n        const currentValue = value.get();\n        if (currentValue !== undefined &&\n            !value.isAnimating() &&\n            !Array.isArray(valueTarget) &&\n            valueTarget === currentValue &&\n            !valueTransition.velocity) {\n            frame.update(() => value.set(valueTarget));\n            continue;\n        }\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.MotionHandoffAnimation) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const startTime = window.MotionHandoffAnimation(appearId, key, frame);\n                if (startTime !== null) {\n                    valueTransition.startTime = startTime;\n                    isHandoff = true;\n                }\n            }\n        }\n        addValueToWillChange(visualElement, key);\n        const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;\n        value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff));\n        const animation = value.animation;\n        if (animation) {\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        const applyTransitionEnd = () => frame.update(() => {\n            transitionEnd && setTarget(visualElement, transitionEnd);\n        });\n        if (animations.length) {\n            Promise.all(animations).then(applyTransitionEnd);\n        }\n        else {\n            applyTransitionEnd();\n        }\n    }\n    return animations;\n}\n\nexport { animateTarget };\n//# sourceMappingURL=visual-element-target.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;AAeA,SAAS,qBAAqB,EAAE,eAAe,kBAAkB,KAAK;CAClE,MAAM,cAAc,cAAc,eAAe,IAAI,IAAI,eAAe,SAAS;AACjF,gBAAe,OAAO;AACtB,QAAO;;AAEX,SAAS,cAAc,eAAe,qBAAqB,EAAE,QAAQ,GAAG,oBAAoB,SAAS,EAAE,EAAE;CACrG,IAAI,EAAE,YAAY,eAAe,GAAG,WAAW;CAC/C,MAAM,oBAAoB,cAAc,sBAAsB;AAC9D,cAAa,aACP,kBAAkB,YAAY,kBAAkB,GAChD;CACN,MAAM,eAAe,YAAY;AACjC,KAAI,mBACA,cAAa;CACjB,MAAM,aAAa,EAAE;CACrB,MAAM,qBAAqB,QACvB,cAAc,kBACd,cAAc,eAAe,UAAU,CAAC;AAC5C,MAAK,MAAM,OAAO,QAAQ;EACtB,MAAM,QAAQ,cAAc,SAAS,KAAK,cAAc,aAAa,QAAQ,KAAK;EAClF,MAAM,cAAc,OAAO;AAC3B,MAAI,gBAAgB,KAAA,KACf,sBACG,qBAAqB,oBAAoB,IAAI,CACjD;EAEJ,MAAM,kBAAkB;GACpB;GACA,GAAG,mBAAmB,cAAc,EAAE,EAAE,IAAI;GAC/C;;;;;;EAMD,MAAM,eAAe,MAAM,KAAK;AAChC,MAAI,iBAAiB,KAAA,KACjB,CAAC,MAAM,aAAa,IACpB,CAAC,MAAM,QAAQ,YAAY,IAC3B,gBAAgB,gBAChB,CAAC,gBAAgB,UAAU;AAC3B,SAAM,aAAa,MAAM,IAAI,YAAY,CAAC;AAC1C;;;;;;EAMJ,IAAI,YAAY;AAChB,MAAI,OAAO,wBAAwB;GAC/B,MAAM,WAAW,qBAAqB,cAAc;AACpD,OAAI,UAAU;IACV,MAAM,YAAY,OAAO,uBAAuB,UAAU,KAAK,MAAM;AACrE,QAAI,cAAc,MAAM;AACpB,qBAAgB,YAAY;AAC5B,iBAAY;;;;AAIxB,uBAAqB,eAAe,IAAI;EACxC,MAAM,qBAAqB,gBAAgB,cAAc;AACzD,QAAM,MAAM,mBAAmB,KAAK,OAAO,aAAa,sBAAsB,eAAe,IAAI,IAAI,GAC/F,EAAE,MAAM,OAAO,GACf,iBAAiB,eAAe,UAAU,CAAC;EACjD,MAAM,YAAY,MAAM;AACxB,MAAI,UACA,YAAW,KAAK,UAAU;;AAGlC,KAAI,eAAe;EACf,MAAM,2BAA2B,MAAM,aAAa;AAChD,oBAAiB,UAAU,eAAe,cAAc;IAC1D;AACF,MAAI,WAAW,OACX,SAAQ,IAAI,WAAW,CAAC,KAAK,mBAAmB;MAGhD,qBAAoB;;AAG5B,QAAO"}

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.js

@@ -0,0 +1,46 @@
+import { calcChildStagger } from "../utils/calc-child-stagger.js";
+import { resolveVariant } from "../../render/utils/resolve-dynamic-variants.js";
+import { animateTarget } from "./visual-element-target.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs
+function animateVariant(visualElement, variant, options = {}) {
+	const resolved = resolveVariant(visualElement, variant, options.type === "exit" ? visualElement.presenceContext?.custom : void 0);
+	let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
+	if (options.transitionOverride) transition = options.transitionOverride;
+	/**
+	* If we have a variant, create a callback that runs it as an animation.
+	* Otherwise, we resolve a Promise immediately for a composable no-op.
+	*/
+	const getAnimation = resolved ? () => Promise.all(animateTarget(visualElement, resolved, options)) : () => Promise.resolve();
+	/**
+	* If we have children, create a callback that runs all their animations.
+	* Otherwise, we resolve a Promise immediately for a composable no-op.
+	*/
+	const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size ? (forwardDelay = 0) => {
+		const { delayChildren = 0, staggerChildren, staggerDirection } = transition;
+		return animateChildren(visualElement, variant, forwardDelay, delayChildren, staggerChildren, staggerDirection, options);
+	} : () => Promise.resolve();
+	/**
+	* If the transition explicitly defines a "when" option, we need to resolve either
+	* this animation or all children animations before playing the other.
+	*/
+	const { when } = transition;
+	if (when) {
+		const [first, last] = when === "beforeChildren" ? [getAnimation, getChildAnimations] : [getChildAnimations, getAnimation];
+		return first().then(() => last());
+	} else return Promise.all([getAnimation(), getChildAnimations(options.delay)]);
+}
+function animateChildren(visualElement, variant, delay = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {
+	const animations = [];
+	for (const child of visualElement.variantChildren) {
+		child.notify("AnimationStart", variant);
+		animations.push(animateVariant(child, variant, {
+			...options,
+			delay: delay + (typeof delayChildren === "function" ? 0 : delayChildren) + calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection)
+		}).then(() => child.notify("AnimationComplete", variant)));
+	}
+	return Promise.all(animations);
+}
+//#endregion
+export { animateVariant };
+
+//# sourceMappingURL=visual-element-variant.js.map

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-element-variant.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs"],"sourcesContent":["import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { calcChildStagger } from '../utils/calc-child-stagger.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? visualElement.presenceContext?.custom\n        : undefined);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getAnimation = resolved\n        ? () => Promise.all(animateTarget(visualElement, resolved, options))\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, forwardDelay, delayChildren, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delay = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    for (const child of visualElement.variantChildren) {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delay +\n                (typeof delayChildren === \"function\" ? 0 : delayChildren) +\n                calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    }\n    return Promise.all(animations);\n}\n\nexport { animateVariant };\n//# sourceMappingURL=visual-element-variant.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AAIA,SAAS,eAAe,eAAe,SAAS,UAAU,EAAE,EAAE;CAC1D,MAAM,WAAW,eAAe,eAAe,SAAS,QAAQ,SAAS,SACnE,cAAc,iBAAiB,SAC/B,KAAA,EAAU;CAChB,IAAI,EAAE,aAAa,cAAc,sBAAsB,IAAI,EAAE,KAAK,YAAY,EAAE;AAChF,KAAI,QAAQ,mBACR,cAAa,QAAQ;;;;;CAMzB,MAAM,eAAe,iBACT,QAAQ,IAAI,cAAc,eAAe,UAAU,QAAQ,CAAC,SAC5D,QAAQ,SAAS;;;;;CAK7B,MAAM,qBAAqB,cAAc,mBAAmB,cAAc,gBAAgB,QACnF,eAAe,MAAM;EACpB,MAAM,EAAE,gBAAgB,GAAG,iBAAiB,qBAAsB;AAClE,SAAO,gBAAgB,eAAe,SAAS,cAAc,eAAe,iBAAiB,kBAAkB,QAAQ;WAEnH,QAAQ,SAAS;;;;;CAK7B,MAAM,EAAE,SAAS;AACjB,KAAI,MAAM;EACN,MAAM,CAAC,OAAO,QAAQ,SAAS,mBACzB,CAAC,cAAc,mBAAmB,GAClC,CAAC,oBAAoB,aAAa;AACxC,SAAO,OAAO,CAAC,WAAW,MAAM,CAAC;OAGjC,QAAO,QAAQ,IAAI,CAAC,cAAc,EAAE,mBAAmB,QAAQ,MAAM,CAAC,CAAC;;AAG/E,SAAS,gBAAgB,eAAe,SAAS,QAAQ,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,mBAAmB,GAAG,SAAS;CAC/H,MAAM,aAAa,EAAE;AACrB,MAAK,MAAM,SAAS,cAAc,iBAAiB;AAC/C,QAAM,OAAO,kBAAkB,QAAQ;AACvC,aAAW,KAAK,eAAe,OAAO,SAAS;GAC3C,GAAG;GACH,OAAO,SACF,OAAO,kBAAkB,aAAa,IAAI,iBAC3C,iBAAiB,cAAc,iBAAiB,OAAO,eAAe,iBAAiB,iBAAiB;GAC/G,CAAC,CAAC,WAAW,MAAM,OAAO,qBAAqB,QAAQ,CAAC,CAAC;;AAE9D,QAAO,QAAQ,IAAI,WAAW"}

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

@@ -0,0 +1,23 @@
+import { resolveVariant } from "../../render/utils/resolve-dynamic-variants.js";
+import { animateTarget } from "./visual-element-target.js";
+import { animateVariant } from "./visual-element-variant.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs
+function animateVisualElement(visualElement, definition, options = {}) {
+	visualElement.notify("AnimationStart", definition);
+	let animation;
+	if (Array.isArray(definition)) {
+		const animations = definition.map((variant) => animateVariant(visualElement, variant, options));
+		animation = Promise.all(animations);
+	} else if (typeof definition === "string") animation = animateVariant(visualElement, definition, options);
+	else {
+		const resolvedDefinition = typeof definition === "function" ? resolveVariant(visualElement, definition, options.custom) : definition;
+		animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));
+	}
+	return animation.then(() => {
+		visualElement.notify("AnimationComplete", definition);
+	});
+}
+//#endregion
+export { animateVisualElement };
+
+//# sourceMappingURL=visual-element.js.map

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-element.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element.mjs"],"sourcesContent":["import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\nimport { animateVariant } from './visual-element-variant.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => {\n        visualElement.notify(\"AnimationComplete\", definition);\n    });\n}\n\nexport { animateVisualElement };\n//# sourceMappingURL=visual-element.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AAIA,SAAS,qBAAqB,eAAe,YAAY,UAAU,EAAE,EAAE;AACnE,eAAc,OAAO,kBAAkB,WAAW;CAClD,IAAI;AACJ,KAAI,MAAM,QAAQ,WAAW,EAAE;EAC3B,MAAM,aAAa,WAAW,KAAK,YAAY,eAAe,eAAe,SAAS,QAAQ,CAAC;AAC/F,cAAY,QAAQ,IAAI,WAAW;YAE9B,OAAO,eAAe,SAC3B,aAAY,eAAe,eAAe,YAAY,QAAQ;MAE7D;EACD,MAAM,qBAAqB,OAAO,eAAe,aAC3C,eAAe,eAAe,YAAY,QAAQ,OAAO,GACzD;AACN,cAAY,QAAQ,IAAI,cAAc,eAAe,oBAAoB,QAAQ,CAAC;;AAEtF,QAAO,UAAU,WAAW;AACxB,gBAAc,OAAO,qBAAqB,WAAW;GACvD"}

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

@@ -0,0 +1,103 @@
+import { containsCSSVariable, isCSSVariableToken } from "../utils/is-css-variable.js";
+import { isNumOrPxType, positionalValues } from "./utils/unit-conversion.js";
+import { KeyframeResolver } from "./KeyframesResolver.js";
+import { getVariableValue } from "../utils/css-variables-conversion.js";
+import { positionalKeys } from "../../render/utils/keys-position.js";
+import { findDimensionValueType } from "../../value/types/dimensions.js";
+import { isNone } from "./utils/is-none.js";
+import { makeNoneKeyframesAnimatable } from "./utils/make-none-animatable.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.mjs
+var DOMKeyframesResolver = class extends KeyframeResolver {
+	constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {
+		super(unresolvedKeyframes, onComplete, name, motionValue, element, true);
+	}
+	readKeyframes() {
+		const { unresolvedKeyframes, element, name } = this;
+		if (!element || !element.current) return;
+		super.readKeyframes();
+		/**
+		* If any keyframe is a CSS variable, we need to find its value by sampling the element
+		*/
+		for (let i = 0; i < unresolvedKeyframes.length; i++) {
+			let keyframe = unresolvedKeyframes[i];
+			if (typeof keyframe === "string") {
+				keyframe = keyframe.trim();
+				if (isCSSVariableToken(keyframe)) {
+					const resolved = getVariableValue(keyframe, element.current);
+					if (resolved !== void 0) unresolvedKeyframes[i] = resolved;
+					if (i === unresolvedKeyframes.length - 1) this.finalKeyframe = keyframe;
+				}
+			}
+		}
+		/**
+		* Resolve "none" values. We do this potentially twice - once before and once after measuring keyframes.
+		* This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which
+		* have a far bigger performance impact.
+		*/
+		this.resolveNoneKeyframes();
+		/**
+		* Check to see if unit type has changed. If so schedule jobs that will
+		* temporarily set styles to the destination keyframes.
+		* Skip if we have more than two keyframes or this isn't a positional value.
+		* TODO: We can throw if there are multiple keyframes and the value type changes.
+		*/
+		if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) return;
+		const [origin, target] = unresolvedKeyframes;
+		const originType = findDimensionValueType(origin);
+		const targetType = findDimensionValueType(target);
+		if (containsCSSVariable(origin) !== containsCSSVariable(target) && positionalValues[name]) {
+			this.needsMeasurement = true;
+			return;
+		}
+		/**
+		* Either we don't recognise these value types or we can animate between them.
+		*/
+		if (originType === targetType) return;
+		/**
+		* If both values are numbers or pixels, we can animate between them by
+		* converting them to numbers.
+		*/
+		if (isNumOrPxType(originType) && isNumOrPxType(targetType)) for (let i = 0; i < unresolvedKeyframes.length; i++) {
+			const value = unresolvedKeyframes[i];
+			if (typeof value === "string") unresolvedKeyframes[i] = parseFloat(value);
+		}
+		else if (positionalValues[name])
+ /**
+		* Else, the only way to resolve this is by measuring the element.
+		*/
+		this.needsMeasurement = true;
+	}
+	resolveNoneKeyframes() {
+		const { unresolvedKeyframes, name } = this;
+		const noneKeyframeIndexes = [];
+		for (let i = 0; i < unresolvedKeyframes.length; i++) if (unresolvedKeyframes[i] === null || isNone(unresolvedKeyframes[i])) noneKeyframeIndexes.push(i);
+		if (noneKeyframeIndexes.length) makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);
+	}
+	measureInitialState() {
+		const { element, unresolvedKeyframes, name } = this;
+		if (!element || !element.current) return;
+		if (name === "height") this.suspendedScrollY = window.pageYOffset;
+		this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
+		unresolvedKeyframes[0] = this.measuredOrigin;
+		const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
+		if (measureKeyframe !== void 0) element.getValue(name, measureKeyframe).jump(measureKeyframe, false);
+	}
+	measureEndState() {
+		const { element, name, unresolvedKeyframes } = this;
+		if (!element || !element.current) return;
+		const value = element.getValue(name);
+		value && value.jump(this.measuredOrigin, false);
+		const finalKeyframeIndex = unresolvedKeyframes.length - 1;
+		const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];
+		unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
+		if (finalKeyframe !== null && this.finalKeyframe === void 0) this.finalKeyframe = finalKeyframe;
+		if (this.removedTransforms?.length) this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {
+			element.getValue(unsetTransformName).set(unsetTransformValue);
+		});
+		this.resolveNoneKeyframes();
+	}
+};
+//#endregion
+export { DOMKeyframesResolver };
+
+//# sourceMappingURL=DOMKeyframesResolver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DOMKeyframesResolver.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.mjs"],"sourcesContent":["import { positionalKeys } from '../../render/utils/keys-position.mjs';\nimport { findDimensionValueType } from '../../value/types/dimensions.mjs';\nimport { getVariableValue } from '../utils/css-variables-conversion.mjs';\nimport { isCSSVariableToken, containsCSSVariable } from '../utils/is-css-variable.mjs';\nimport { KeyframeResolver } from './KeyframesResolver.mjs';\nimport { isNone } from './utils/is-none.mjs';\nimport { makeNoneKeyframesAnimatable } from './utils/make-none-animatable.mjs';\nimport { positionalValues, isNumOrPxType } from './utils/unit-conversion.mjs';\n\nclass DOMKeyframesResolver extends KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {\n        super(unresolvedKeyframes, onComplete, name, motionValue, element, true);\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, element, name } = this;\n        if (!element || !element.current)\n            return;\n        super.readKeyframes();\n        /**\n         * If any keyframe is a CSS variable, we need to find its value by sampling the element\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            let keyframe = unresolvedKeyframes[i];\n            if (typeof keyframe === \"string\") {\n                keyframe = keyframe.trim();\n                if (isCSSVariableToken(keyframe)) {\n                    const resolved = getVariableValue(keyframe, element.current);\n                    if (resolved !== undefined) {\n                        unresolvedKeyframes[i] = resolved;\n                    }\n                    if (i === unresolvedKeyframes.length - 1) {\n                        this.finalKeyframe = keyframe;\n                    }\n                }\n            }\n        }\n        /**\n         * Resolve \"none\" values. We do this potentially twice - once before and once after measuring keyframes.\n         * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which\n         * have a far bigger performance impact.\n         */\n        this.resolveNoneKeyframes();\n        /**\n         * Check to see if unit type has changed. If so schedule jobs that will\n         * temporarily set styles to the destination keyframes.\n         * Skip if we have more than two keyframes or this isn't a positional value.\n         * TODO: We can throw if there are multiple keyframes and the value type changes.\n         */\n        if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {\n            return;\n        }\n        const [origin, target] = unresolvedKeyframes;\n        const originType = findDimensionValueType(origin);\n        const targetType = findDimensionValueType(target);\n        /**\n         * If one keyframe contains embedded CSS variables (e.g. in calc()) and the other\n         * doesn't, we need to measure to convert to pixels. This handles GitHub issue #3410.\n         */\n        const originHasVar = containsCSSVariable(origin);\n        const targetHasVar = containsCSSVariable(target);\n        if (originHasVar !== targetHasVar && positionalValues[name]) {\n            this.needsMeasurement = true;\n            return;\n        }\n        /**\n         * Either we don't recognise these value types or we can animate between them.\n         */\n        if (originType === targetType)\n            return;\n        /**\n         * If both values are numbers or pixels, we can animate between them by\n         * converting them to numbers.\n         */\n        if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {\n            for (let i = 0; i < unresolvedKeyframes.length; i++) {\n                const value = unresolvedKeyframes[i];\n                if (typeof value === \"string\") {\n                    unresolvedKeyframes[i] = parseFloat(value);\n                }\n            }\n        }\n        else if (positionalValues[name]) {\n            /**\n             * Else, the only way to resolve this is by measuring the element.\n             */\n            this.needsMeasurement = true;\n        }\n    }\n    resolveNoneKeyframes() {\n        const { unresolvedKeyframes, name } = this;\n        const noneKeyframeIndexes = [];\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (unresolvedKeyframes[i] === null ||\n                isNone(unresolvedKeyframes[i])) {\n                noneKeyframeIndexes.push(i);\n            }\n        }\n        if (noneKeyframeIndexes.length) {\n            makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);\n        }\n    }\n    measureInitialState() {\n        const { element, unresolvedKeyframes, name } = this;\n        if (!element || !element.current)\n            return;\n        if (name === \"height\") {\n            this.suspendedScrollY = window.pageYOffset;\n        }\n        this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        unresolvedKeyframes[0] = this.measuredOrigin;\n        // Set final key frame to measure after next render\n        const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n        if (measureKeyframe !== undefined) {\n            element.getValue(name, measureKeyframe).jump(measureKeyframe, false);\n        }\n    }\n    measureEndState() {\n        const { element, name, unresolvedKeyframes } = this;\n        if (!element || !element.current)\n            return;\n        const value = element.getValue(name);\n        value && value.jump(this.measuredOrigin, false);\n        const finalKeyframeIndex = unresolvedKeyframes.length - 1;\n        const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];\n        unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        if (finalKeyframe !== null && this.finalKeyframe === undefined) {\n            this.finalKeyframe = finalKeyframe;\n        }\n        // If we removed transform values, reapply them before the next render\n        if (this.removedTransforms?.length) {\n            this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {\n                element\n                    .getValue(unsetTransformName)\n                    .set(unsetTransformValue);\n            });\n        }\n        this.resolveNoneKeyframes();\n    }\n}\n\nexport { DOMKeyframesResolver };\n//# sourceMappingURL=DOMKeyframesResolver.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;AASA,IAAM,uBAAN,cAAmC,iBAAiB;CAChD,YAAY,qBAAqB,YAAY,MAAM,aAAa,SAAS;AACrE,QAAM,qBAAqB,YAAY,MAAM,aAAa,SAAS,KAAK;;CAE5E,gBAAgB;EACZ,MAAM,EAAE,qBAAqB,SAAS,SAAS;AAC/C,MAAI,CAAC,WAAW,CAAC,QAAQ,QACrB;AACJ,QAAM,eAAe;;;;AAIrB,OAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;GACjD,IAAI,WAAW,oBAAoB;AACnC,OAAI,OAAO,aAAa,UAAU;AAC9B,eAAW,SAAS,MAAM;AAC1B,QAAI,mBAAmB,SAAS,EAAE;KAC9B,MAAM,WAAW,iBAAiB,UAAU,QAAQ,QAAQ;AAC5D,SAAI,aAAa,KAAA,EACb,qBAAoB,KAAK;AAE7B,SAAI,MAAM,oBAAoB,SAAS,EACnC,MAAK,gBAAgB;;;;;;;;;AAUrC,OAAK,sBAAsB;;;;;;;AAO3B,MAAI,CAAC,eAAe,IAAI,KAAK,IAAI,oBAAoB,WAAW,EAC5D;EAEJ,MAAM,CAAC,QAAQ,UAAU;EACzB,MAAM,aAAa,uBAAuB,OAAO;EACjD,MAAM,aAAa,uBAAuB,OAAO;AAOjD,MAFqB,oBAAoB,OAAO,KAC3B,oBAAoB,OAAO,IACX,iBAAiB,OAAO;AACzD,QAAK,mBAAmB;AACxB;;;;;AAKJ,MAAI,eAAe,WACf;;;;;AAKJ,MAAI,cAAc,WAAW,IAAI,cAAc,WAAW,CACtD,MAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;GACjD,MAAM,QAAQ,oBAAoB;AAClC,OAAI,OAAO,UAAU,SACjB,qBAAoB,KAAK,WAAW,MAAM;;WAI7C,iBAAiB;;;;AAItB,OAAK,mBAAmB;;CAGhC,uBAAuB;EACnB,MAAM,EAAE,qBAAqB,SAAS;EACtC,MAAM,sBAAsB,EAAE;AAC9B,OAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,QAAQ,IAC5C,KAAI,oBAAoB,OAAO,QAC3B,OAAO,oBAAoB,GAAG,CAC9B,qBAAoB,KAAK,EAAE;AAGnC,MAAI,oBAAoB,OACpB,6BAA4B,qBAAqB,qBAAqB,KAAK;;CAGnF,sBAAsB;EAClB,MAAM,EAAE,SAAS,qBAAqB,SAAS;AAC/C,MAAI,CAAC,WAAW,CAAC,QAAQ,QACrB;AACJ,MAAI,SAAS,SACT,MAAK,mBAAmB,OAAO;AAEnC,OAAK,iBAAiB,iBAAiB,MAAM,QAAQ,oBAAoB,EAAE,OAAO,iBAAiB,QAAQ,QAAQ,CAAC;AACpH,sBAAoB,KAAK,KAAK;EAE9B,MAAM,kBAAkB,oBAAoB,oBAAoB,SAAS;AACzE,MAAI,oBAAoB,KAAA,EACpB,SAAQ,SAAS,MAAM,gBAAgB,CAAC,KAAK,iBAAiB,MAAM;;CAG5E,kBAAkB;EACd,MAAM,EAAE,SAAS,MAAM,wBAAwB;AAC/C,MAAI,CAAC,WAAW,CAAC,QAAQ,QACrB;EACJ,MAAM,QAAQ,QAAQ,SAAS,KAAK;AACpC,WAAS,MAAM,KAAK,KAAK,gBAAgB,MAAM;EAC/C,MAAM,qBAAqB,oBAAoB,SAAS;EACxD,MAAM,gBAAgB,oBAAoB;AAC1C,sBAAoB,sBAAsB,iBAAiB,MAAM,QAAQ,oBAAoB,EAAE,OAAO,iBAAiB,QAAQ,QAAQ,CAAC;AACxI,MAAI,kBAAkB,QAAQ,KAAK,kBAAkB,KAAA,EACjD,MAAK,gBAAgB;AAGzB,MAAI,KAAK,mBAAmB,OACxB,MAAK,kBAAkB,SAAS,CAAC,oBAAoB,yBAAyB;AAC1E,WACK,SAAS,mBAAmB,CAC5B,IAAI,oBAAoB;IAC/B;AAEN,OAAK,sBAAsB"}

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

@@ -0,0 +1,126 @@
+import { frame } from "../../frameloop/frame.js";
+import { fillWildcards } from "./utils/fill-wildcards.js";
+import { removeNonTranslationalTransform } from "./utils/unit-conversion.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs
+var toResolve = /* @__PURE__ */ new Set();
+var isScheduled = false;
+var anyNeedsMeasurement = false;
+var isForced = false;
+function measureAllKeyframes() {
+	if (anyNeedsMeasurement) {
+		const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);
+		const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));
+		const transformsToRestore = /* @__PURE__ */ new Map();
+		/**
+		* Write pass
+		* If we're measuring elements we want to remove bounding box-changing transforms.
+		*/
+		elementsToMeasure.forEach((element) => {
+			const removedTransforms = removeNonTranslationalTransform(element);
+			if (!removedTransforms.length) return;
+			transformsToRestore.set(element, removedTransforms);
+			element.render();
+		});
+		resolversToMeasure.forEach((resolver) => resolver.measureInitialState());
+		elementsToMeasure.forEach((element) => {
+			element.render();
+			const restore = transformsToRestore.get(element);
+			if (restore) restore.forEach(([key, value]) => {
+				element.getValue(key)?.set(value);
+			});
+		});
+		resolversToMeasure.forEach((resolver) => resolver.measureEndState());
+		resolversToMeasure.forEach((resolver) => {
+			if (resolver.suspendedScrollY !== void 0) window.scrollTo(0, resolver.suspendedScrollY);
+		});
+	}
+	anyNeedsMeasurement = false;
+	isScheduled = false;
+	toResolve.forEach((resolver) => resolver.complete(isForced));
+	toResolve.clear();
+}
+function readAllKeyframes() {
+	toResolve.forEach((resolver) => {
+		resolver.readKeyframes();
+		if (resolver.needsMeasurement) anyNeedsMeasurement = true;
+	});
+}
+function flushKeyframeResolvers() {
+	isForced = true;
+	readAllKeyframes();
+	measureAllKeyframes();
+	isForced = false;
+}
+var KeyframeResolver = class {
+	constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {
+		this.state = "pending";
+		/**
+		* Track whether this resolver is async. If it is, it'll be added to the
+		* resolver queue and flushed in the next frame. Resolvers that aren't going
+		* to trigger read/write thrashing don't need to be async.
+		*/
+		this.isAsync = false;
+		/**
+		* Track whether this resolver needs to perform a measurement
+		* to resolve its keyframes.
+		*/
+		this.needsMeasurement = false;
+		this.unresolvedKeyframes = [...unresolvedKeyframes];
+		this.onComplete = onComplete;
+		this.name = name;
+		this.motionValue = motionValue;
+		this.element = element;
+		this.isAsync = isAsync;
+	}
+	scheduleResolve() {
+		this.state = "scheduled";
+		if (this.isAsync) {
+			toResolve.add(this);
+			if (!isScheduled) {
+				isScheduled = true;
+				frame.read(readAllKeyframes);
+				frame.resolveKeyframes(measureAllKeyframes);
+			}
+		} else {
+			this.readKeyframes();
+			this.complete();
+		}
+	}
+	readKeyframes() {
+		const { unresolvedKeyframes, name, element, motionValue } = this;
+		if (unresolvedKeyframes[0] === null) {
+			const currentValue = motionValue?.get();
+			const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
+			if (currentValue !== void 0) unresolvedKeyframes[0] = currentValue;
+			else if (element && name) {
+				const valueAsRead = element.readValue(name, finalKeyframe);
+				if (valueAsRead !== void 0 && valueAsRead !== null) unresolvedKeyframes[0] = valueAsRead;
+			}
+			if (unresolvedKeyframes[0] === void 0) unresolvedKeyframes[0] = finalKeyframe;
+			if (motionValue && currentValue === void 0) motionValue.set(unresolvedKeyframes[0]);
+		}
+		fillWildcards(unresolvedKeyframes);
+	}
+	setFinalKeyframe() {}
+	measureInitialState() {}
+	renderEndStyles() {}
+	measureEndState() {}
+	complete(isForcedComplete = false) {
+		this.state = "complete";
+		this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, isForcedComplete);
+		toResolve.delete(this);
+	}
+	cancel() {
+		if (this.state === "scheduled") {
+			toResolve.delete(this);
+			this.state = "pending";
+		}
+	}
+	resume() {
+		if (this.state === "pending") this.scheduleResolve();
+	}
+};
+//#endregion
+export { KeyframeResolver, flushKeyframeResolvers };
+
+//# sourceMappingURL=KeyframesResolver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KeyframesResolver.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs"],"sourcesContent":["import { fillWildcards } from './utils/fill-wildcards.mjs';\nimport { removeNonTranslationalTransform } from './utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nlet isForced = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    element.getValue(key)?.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete(isForced));\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    isForced = true;\n    readAllKeyframes();\n    measureAllKeyframes();\n    isForced = false;\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        this.state = \"pending\";\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.state = \"scheduled\";\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        // If initial keyframe is null we need to read it from the DOM\n        if (unresolvedKeyframes[0] === null) {\n            const currentValue = motionValue?.get();\n            // TODO: This doesn't work if the final keyframe is a wildcard\n            const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n            if (currentValue !== undefined) {\n                unresolvedKeyframes[0] = currentValue;\n            }\n            else if (element && name) {\n                const valueAsRead = element.readValue(name, finalKeyframe);\n                if (valueAsRead !== undefined && valueAsRead !== null) {\n                    unresolvedKeyframes[0] = valueAsRead;\n                }\n            }\n            if (unresolvedKeyframes[0] === undefined) {\n                unresolvedKeyframes[0] = finalKeyframe;\n            }\n            if (motionValue && currentValue === undefined) {\n                motionValue.set(unresolvedKeyframes[0]);\n            }\n        }\n        fillWildcards(unresolvedKeyframes);\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete(isForcedComplete = false) {\n        this.state = \"complete\";\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, isForcedComplete);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (this.state === \"scheduled\") {\n            toResolve.delete(this);\n            this.state = \"pending\";\n        }\n    }\n    resume() {\n        if (this.state === \"pending\")\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n//# sourceMappingURL=KeyframesResolver.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AAIA,IAAM,4BAAY,IAAI,KAAK;AAC3B,IAAI,cAAc;AAClB,IAAI,sBAAsB;AAC1B,IAAI,WAAW;AACf,SAAS,sBAAsB;AAC3B,KAAI,qBAAqB;EACrB,MAAM,qBAAqB,MAAM,KAAK,UAAU,CAAC,QAAQ,aAAa,SAAS,iBAAiB;EAChG,MAAM,oBAAoB,IAAI,IAAI,mBAAmB,KAAK,aAAa,SAAS,QAAQ,CAAC;EACzF,MAAM,sCAAsB,IAAI,KAAK;;;;;AAKrC,oBAAkB,SAAS,YAAY;GACnC,MAAM,oBAAoB,gCAAgC,QAAQ;AAClE,OAAI,CAAC,kBAAkB,OACnB;AACJ,uBAAoB,IAAI,SAAS,kBAAkB;AACnD,WAAQ,QAAQ;IAClB;AAEF,qBAAmB,SAAS,aAAa,SAAS,qBAAqB,CAAC;AAExE,oBAAkB,SAAS,YAAY;AACnC,WAAQ,QAAQ;GAChB,MAAM,UAAU,oBAAoB,IAAI,QAAQ;AAChD,OAAI,QACA,SAAQ,SAAS,CAAC,KAAK,WAAW;AAC9B,YAAQ,SAAS,IAAI,EAAE,IAAI,MAAM;KACnC;IAER;AAEF,qBAAmB,SAAS,aAAa,SAAS,iBAAiB,CAAC;AAEpE,qBAAmB,SAAS,aAAa;AACrC,OAAI,SAAS,qBAAqB,KAAA,EAC9B,QAAO,SAAS,GAAG,SAAS,iBAAiB;IAEnD;;AAEN,uBAAsB;AACtB,eAAc;AACd,WAAU,SAAS,aAAa,SAAS,SAAS,SAAS,CAAC;AAC5D,WAAU,OAAO;;AAErB,SAAS,mBAAmB;AACxB,WAAU,SAAS,aAAa;AAC5B,WAAS,eAAe;AACxB,MAAI,SAAS,iBACT,uBAAsB;GAE5B;;AAEN,SAAS,yBAAyB;AAC9B,YAAW;AACX,mBAAkB;AAClB,sBAAqB;AACrB,YAAW;;AAEf,IAAM,mBAAN,MAAuB;CACnB,YAAY,qBAAqB,YAAY,MAAM,aAAa,SAAS,UAAU,OAAO;AACtF,OAAK,QAAQ;;;;;;AAMb,OAAK,UAAU;;;;;AAKf,OAAK,mBAAmB;AACxB,OAAK,sBAAsB,CAAC,GAAG,oBAAoB;AACnD,OAAK,aAAa;AAClB,OAAK,OAAO;AACZ,OAAK,cAAc;AACnB,OAAK,UAAU;AACf,OAAK,UAAU;;CAEnB,kBAAkB;AACd,OAAK,QAAQ;AACb,MAAI,KAAK,SAAS;AACd,aAAU,IAAI,KAAK;AACnB,OAAI,CAAC,aAAa;AACd,kBAAc;AACd,UAAM,KAAK,iBAAiB;AAC5B,UAAM,iBAAiB,oBAAoB;;SAG9C;AACD,QAAK,eAAe;AACpB,QAAK,UAAU;;;CAGvB,gBAAgB;EACZ,MAAM,EAAE,qBAAqB,MAAM,SAAS,gBAAgB;AAE5D,MAAI,oBAAoB,OAAO,MAAM;GACjC,MAAM,eAAe,aAAa,KAAK;GAEvC,MAAM,gBAAgB,oBAAoB,oBAAoB,SAAS;AACvE,OAAI,iBAAiB,KAAA,EACjB,qBAAoB,KAAK;YAEpB,WAAW,MAAM;IACtB,MAAM,cAAc,QAAQ,UAAU,MAAM,cAAc;AAC1D,QAAI,gBAAgB,KAAA,KAAa,gBAAgB,KAC7C,qBAAoB,KAAK;;AAGjC,OAAI,oBAAoB,OAAO,KAAA,EAC3B,qBAAoB,KAAK;AAE7B,OAAI,eAAe,iBAAiB,KAAA,EAChC,aAAY,IAAI,oBAAoB,GAAG;;AAG/C,gBAAc,oBAAoB;;CAEtC,mBAAmB;CACnB,sBAAsB;CACtB,kBAAkB;CAClB,kBAAkB;CAClB,SAAS,mBAAmB,OAAO;AAC/B,OAAK,QAAQ;AACb,OAAK,WAAW,KAAK,qBAAqB,KAAK,eAAe,iBAAiB;AAC/E,YAAU,OAAO,KAAK;;CAE1B,SAAS;AACL,MAAI,KAAK,UAAU,aAAa;AAC5B,aAAU,OAAO,KAAK;AACtB,QAAK,QAAQ;;;CAGrB,SAAS;AACL,MAAI,KAAK,UAAU,UACf,MAAK,iBAAiB"}

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

@@ -0,0 +1,11 @@
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/get-final.mjs
+var isNotNull = (value) => value !== null;
+function getFinalKeyframe(keyframes, { repeat, repeatType = "loop" }, finalKeyframe, speed = 1) {
+	const resolvedKeyframes = keyframes.filter(isNotNull);
+	const index = speed < 0 || repeat && repeatType !== "loop" && repeat % 2 === 1 ? 0 : resolvedKeyframes.length - 1;
+	return !index || finalKeyframe === void 0 ? resolvedKeyframes[index] : finalKeyframe;
+}
+//#endregion
+export { getFinalKeyframe };
+
+//# sourceMappingURL=get-final.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-final.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/get-final.mjs"],"sourcesContent":["const isNotNull = (value) => value !== null;\nfunction getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }, finalKeyframe, speed = 1) {\n    const resolvedKeyframes = keyframes.filter(isNotNull);\n    const useFirstKeyframe = speed < 0 || (repeat && repeatType !== \"loop\" && repeat % 2 === 1);\n    const index = useFirstKeyframe ? 0 : resolvedKeyframes.length - 1;\n    return !index || finalKeyframe === undefined\n        ? resolvedKeyframes[index]\n        : finalKeyframe;\n}\n\nexport { getFinalKeyframe };\n//# sourceMappingURL=get-final.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";AAAA,IAAM,aAAa,UAAU,UAAU;AACvC,SAAS,iBAAiB,WAAW,EAAE,QAAQ,aAAa,UAAU,eAAe,QAAQ,GAAG;CAC5F,MAAM,oBAAoB,UAAU,OAAO,UAAU;CAErD,MAAM,QADmB,QAAQ,KAAM,UAAU,eAAe,UAAU,SAAS,MAAM,IACxD,IAAI,kBAAkB,SAAS;AAChE,QAAO,CAAC,SAAS,kBAAkB,KAAA,IAC7B,kBAAkB,SAClB"}

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

@@ -0,0 +1,11 @@
+import { fillOffset } from "./fill.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.mjs
+function defaultOffset(arr) {
+	const offset = [0];
+	fillOffset(offset, arr.length - 1);
+	return offset;
+}
+//#endregion
+export { defaultOffset };
+
+//# sourceMappingURL=default.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"default.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.mjs"],"sourcesContent":["import { fillOffset } from './fill.mjs';\n\nfunction defaultOffset(arr) {\n    const offset = [0];\n    fillOffset(offset, arr.length - 1);\n    return offset;\n}\n\nexport { defaultOffset };\n//# sourceMappingURL=default.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;AAEA,SAAS,cAAc,KAAK;CACxB,MAAM,SAAS,CAAC,EAAE;AAClB,YAAW,QAAQ,IAAI,SAAS,EAAE;AAClC,QAAO"}

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

@@ -0,0 +1,14 @@
+import { progress } from "../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/progress.js";
+import { mixNumber } from "../../../utils/mix/number.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.mjs
+function fillOffset(offset, remaining) {
+	const min = offset[offset.length - 1];
+	for (let i = 1; i <= remaining; i++) {
+		const offsetProgress = progress(0, remaining, i);
+		offset.push(mixNumber(min, 1, offsetProgress));
+	}
+}
+//#endregion
+export { fillOffset };
+
+//# sourceMappingURL=fill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fill.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.mjs"],"sourcesContent":["import { progress } from 'motion-utils';\nimport { mixNumber } from '../../../utils/mix/number.mjs';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mixNumber(min, 1, offsetProgress));\n    }\n}\n\nexport { fillOffset };\n//# sourceMappingURL=fill.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;AAGA,SAAS,WAAW,QAAQ,WAAW;CACnC,MAAM,MAAM,OAAO,OAAO,SAAS;AACnC,MAAK,IAAI,IAAI,GAAG,KAAK,WAAW,KAAK;EACjC,MAAM,iBAAiB,SAAS,GAAG,WAAW,EAAE;AAChD,SAAO,KAAK,UAAU,KAAK,GAAG,eAAe,CAAC"}

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

@@ -0,0 +1,8 @@
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.mjs
+function convertOffsetToTimes(offset, duration) {
+	return offset.map((o) => o * duration);
+}
+//#endregion
+export { convertOffsetToTimes };
+
+//# sourceMappingURL=time.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.mjs"],"sourcesContent":["function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n//# sourceMappingURL=time.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAS,qBAAqB,QAAQ,UAAU;AAC5C,QAAO,OAAO,KAAK,MAAM,IAAI,SAAS"}

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.js

@@ -0,0 +1,8 @@
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.mjs
+function fillWildcards(keyframes) {
+	for (let i = 1; i < keyframes.length; i++) keyframes[i] ?? (keyframes[i] = keyframes[i - 1]);
+}
+//#endregion
+export { fillWildcards };
+
+//# sourceMappingURL=fill-wildcards.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fill-wildcards.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.mjs"],"sourcesContent":["function fillWildcards(keyframes) {\n    for (let i = 1; i < keyframes.length; i++) {\n        keyframes[i] ?? (keyframes[i] = keyframes[i - 1]);\n    }\n}\n\nexport { fillWildcards };\n//# sourceMappingURL=fill-wildcards.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAS,cAAc,WAAW;AAC9B,MAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,IAClC,WAAU,OAAO,UAAU,KAAK,UAAU,IAAI"}

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

@@ -0,0 +1,11 @@
+import { isZeroValueString } from "../../../../../../../../motion-utils@12.36.0/node_modules/motion-utils/dist/es/is-zero-value-string.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/is-none.mjs
+function isNone(value) {
+	if (typeof value === "number") return value === 0;
+	else if (value !== null) return value === "none" || value === "0" || isZeroValueString(value);
+	else return true;
+}
+//#endregion
+export { isNone };
+
+//# sourceMappingURL=is-none.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-none.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/is-none.mjs"],"sourcesContent":["import { isZeroValueString } from 'motion-utils';\n\nfunction isNone(value) {\n    if (typeof value === \"number\") {\n        return value === 0;\n    }\n    else if (value !== null) {\n        return value === \"none\" || value === \"0\" || isZeroValueString(value);\n    }\n    else {\n        return true;\n    }\n}\n\nexport { isNone };\n//# sourceMappingURL=is-none.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;AAEA,SAAS,OAAO,OAAO;AACnB,KAAI,OAAO,UAAU,SACjB,QAAO,UAAU;UAEZ,UAAU,KACf,QAAO,UAAU,UAAU,UAAU,OAAO,kBAAkB,MAAM;KAGpE,QAAO"}

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/make-none-animatable.js

@@ -0,0 +1,28 @@
+import { analyseComplexValue } from "../../../value/types/complex/index.js";
+import { getAnimatableNone } from "../../../value/types/utils/animatable-none.js";
+//#region ../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/make-none-animatable.mjs
+/**
+* If we encounter keyframes like "none" or "0" and we also have keyframes like
+* "#fff" or "200px 200px" we want to find a keyframe to serve as a template for
+* the "none" keyframes. In this case "#fff" or "200px 200px" - then these get turned into
+* zero equivalents, i.e. "#fff0" or "0px 0px".
+*/
+var invalidTemplates = new Set([
+	"auto",
+	"none",
+	"0"
+]);
+function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
+	let i = 0;
+	let animatableTemplate = void 0;
+	while (i < unresolvedKeyframes.length && !animatableTemplate) {
+		const keyframe = unresolvedKeyframes[i];
+		if (typeof keyframe === "string" && !invalidTemplates.has(keyframe) && analyseComplexValue(keyframe).values.length) animatableTemplate = unresolvedKeyframes[i];
+		i++;
+	}
+	if (animatableTemplate && name) for (const noneIndex of noneKeyframeIndexes) unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);
+}
+//#endregion
+export { makeNoneKeyframesAnimatable };
+
+//# sourceMappingURL=make-none-animatable.js.map

package/dist/node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/make-none-animatable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-none-animatable.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/utils/make-none-animatable.mjs"],"sourcesContent":["import { analyseComplexValue } from '../../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../../../value/types/utils/animatable-none.mjs';\n\n/**\n * If we encounter keyframes like \"none\" or \"0\" and we also have keyframes like\n * \"#fff\" or \"200px 200px\" we want to find a keyframe to serve as a template for\n * the \"none\" keyframes. In this case \"#fff\" or \"200px 200px\" - then these get turned into\n * zero equivalents, i.e. \"#fff0\" or \"0px 0px\".\n */\nconst invalidTemplates = new Set([\"auto\", \"none\", \"0\"]);\nfunction makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {\n    let i = 0;\n    let animatableTemplate = undefined;\n    while (i < unresolvedKeyframes.length && !animatableTemplate) {\n        const keyframe = unresolvedKeyframes[i];\n        if (typeof keyframe === \"string\" &&\n            !invalidTemplates.has(keyframe) &&\n            analyseComplexValue(keyframe).values.length) {\n            animatableTemplate = unresolvedKeyframes[i];\n        }\n        i++;\n    }\n    if (animatableTemplate && name) {\n        for (const noneIndex of noneKeyframeIndexes) {\n            unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);\n        }\n    }\n}\n\nexport { makeNoneKeyframesAnimatable };\n//# sourceMappingURL=make-none-animatable.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;AASA,IAAM,mBAAmB,IAAI,IAAI;CAAC;CAAQ;CAAQ;CAAI,CAAC;AACvD,SAAS,4BAA4B,qBAAqB,qBAAqB,MAAM;CACjF,IAAI,IAAI;CACR,IAAI,qBAAqB,KAAA;AACzB,QAAO,IAAI,oBAAoB,UAAU,CAAC,oBAAoB;EAC1D,MAAM,WAAW,oBAAoB;AACrC,MAAI,OAAO,aAAa,YACpB,CAAC,iBAAiB,IAAI,SAAS,IAC/B,oBAAoB,SAAS,CAAC,OAAO,OACrC,sBAAqB,oBAAoB;AAE7C;;AAEJ,KAAI,sBAAsB,KACtB,MAAK,MAAM,aAAa,oBACpB,qBAAoB,aAAa,kBAAkB,MAAM,mBAAmB"}