@hirely/ui 0.1.8 → 0.1.9

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

@@ -1 +0,0 @@
-{"version":3,"file":"spring.cjs.js","names":["secondsToMilliseconds","clamp","millisecondsToSeconds","calcGeneratorDuration","maxGeneratorDuration","generateLinearEasing","createGeneratorEasing"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/spring.es.js

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

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

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

@@ -1,2 +0,0 @@
-require("../../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");var e=2e4;function t(e){let t=0,n=e.next(t);for(;!n.done&&t<2e4;)t+=50,n=e.next(t);return t>=2e4?1/0:t}exports.calcGeneratorDuration=t,exports.maxGeneratorDuration=e;
-//# sourceMappingURL=calc-duration.cjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"calc-duration.cjs.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"2EAIA,IAAM,EAAuB,IAC7B,SAAS,EAAsB,EAAW,CACtC,IAAI,EAAW,EAEX,EAAQ,EAAU,KAAK,CAAQ,EACnC,KAAO,CAAC,EAAM,MAAQ,EAAA,KAClB,GAAY,GACZ,EAAQ,EAAU,KAAK,CAAQ,EAEnC,OAAO,GAAA,IAAmC,IAAW,CACzD"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"calc-duration.es.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs"],"sourcesContent":["/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n//# sourceMappingURL=calc-duration.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";AAIA,IAAM,IAAuB;AAC7B,SAAS,EAAsB,GAAW;CACtC,IAAI,IAAW,GAEX,IAAQ,EAAU,KAAK,CAAQ;CACnC,OAAO,CAAC,EAAM,QAAQ,IAAA,MAElB,AADA,KAAY,IACZ,IAAQ,EAAU,KAAK,CAAQ;CAEnC,OAAO,KAAA,MAAmC,WAAW;AACzD"}

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

@@ -1,2 +0,0 @@
-require("../../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/time-conversion.cjs.js"),t=require("./calc-duration.cjs.js");function n(n,r=100,i){let a=i({...n,keyframes:[0,r]}),o=Math.min(t.calcGeneratorDuration(a),t.maxGeneratorDuration);return{type:`keyframes`,ease:e=>a.next(o*e).value/r,duration:e.millisecondsToSeconds(o)}}exports.createGeneratorEasing=n;
-//# sourceMappingURL=create-generator-easing.cjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create-generator-easing.cjs.js","names":["calcGeneratorDuration","maxGeneratorDuration","millisecondsToSeconds"],"sources":["../../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"wOAMA,SAAS,EAAsB,EAAS,EAAQ,IAAK,EAAiB,CAClE,IAAM,EAAY,EAAgB,CAAE,GAAG,EAAS,UAAW,CAAC,EAAG,CAAK,CAAE,CAAC,EACjE,EAAW,KAAK,IAAIA,EAAAA,sBAAsB,CAAS,EAAGC,EAAAA,oBAAoB,EAChF,MAAO,CACH,KAAM,YACN,KAAO,GACI,EAAU,KAAK,EAAW,CAAQ,CAAC,CAAC,MAAQ,EAEvD,SAAUC,EAAAA,sBAAsB,CAAQ,CAC5C,CACJ"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"create-generator-easing.es.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs"],"sourcesContent":["import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n//# sourceMappingURL=create-generator-easing.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;AAMA,SAAS,EAAsB,GAAS,IAAQ,KAAK,GAAiB;CAClE,IAAM,IAAY,EAAgB;EAAE,GAAG;EAAS,WAAW,CAAC,GAAG,CAAK;CAAE,CAAC,GACjE,IAAW,KAAK,IAAI,EAAsB,CAAS,GAAG,CAAoB;CAChF,OAAO;EACH,MAAM;EACN,OAAO,MACI,EAAU,KAAK,IAAW,CAAQ,CAAC,CAAC,QAAQ;EAEvD,UAAU,EAAsB,CAAQ;CAC5C;AACJ"}

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

@@ -1,2 +0,0 @@
-require("../../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");function e(e){return typeof e==`function`&&`applyToOptions`in e}exports.isGenerator=e;
-//# sourceMappingURL=is-generator.cjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-generator.cjs.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"2EAAA,SAAS,EAAY,EAAM,CACvB,OAAO,OAAO,GAAS,YAAc,mBAAoB,CAC7D"}

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

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

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

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

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

@@ -1,2 +0,0 @@
-require("../../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../../../../../../../motion-utils@12.39.0/node_modules/motion-utils/dist/es/velocity-per-second.cjs.js");var t=5;function n(n,r,i){let a=Math.max(r-t,0);return e.velocityPerSecond(i-n(a),r-a)}exports.getGeneratorVelocity=n;
-//# sourceMappingURL=velocity.cjs.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"velocity.cjs.js","names":["velocityPerSecond"],"sources":["../../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"wMAEA,IAAM,EAAyB,EAC/B,SAAS,EAAqB,EAAc,EAAG,EAAS,CACpD,IAAM,EAAQ,KAAK,IAAI,EAAI,EAAwB,CAAC,EACpD,OAAOA,EAAAA,kBAAkB,EAAU,EAAa,CAAK,EAAG,EAAI,CAAK,CACrE"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"velocity.es.js","names":[],"sources":["../../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs"],"sourcesContent":["import { velocityPerSecond } from 'motion-utils';\n\nconst velocitySampleDuration = 5; // ms\nfunction getGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { getGeneratorVelocity };\n//# sourceMappingURL=velocity.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;AAEA,IAAM,IAAyB;AAC/B,SAAS,EAAqB,GAAc,GAAG,GAAS;CACpD,IAAM,IAAQ,KAAK,IAAI,IAAI,GAAwB,CAAC;CACpD,OAAO,EAAkB,IAAU,EAAa,CAAK,GAAG,IAAI,CAAK;AACrE"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"motion-value.cjs.js","names":["getValueTransition","secondsToMilliseconds","isTransitionDefined","getDefaultTransition","MotionGlobalConfig","getFinalKeyframe","JSAnimation","AsyncMotionValueAnimation"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["import { secondsToMilliseconds, MotionGlobalConfig } from 'motion-utils';\nimport { AsyncMotionValueAnimation } from '../AsyncMotionValueAnimation.mjs';\nimport { JSAnimation } from '../JSAnimation.mjs';\nimport { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { makeAnimationInstant } from '../utils/make-animation-instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getFinalKeyframe } from '../keyframes/get-final.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    const options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unique transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        Object.assign(options, getDefaultTransition(name, options));\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    options.duration && (options.duration = secondsToMilliseconds(options.duration));\n    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));\n    /**\n     * Support deprecated way to set initial value. Prefer keyframe syntax.\n     */\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        makeAnimationInstant(options);\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (MotionGlobalConfig.instantAnimations ||\n        MotionGlobalConfig.skipAnimations ||\n        element?.shouldSkipAnimations ||\n        valueTransition.skipAnimations) {\n        shouldSkip = true;\n        makeAnimationInstant(options);\n        options.delay = 0;\n    }\n    /**\n     * If the transition type or easing has been explicitly set by the user\n     * then we don't want to allow flattening the animation.\n     */\n    options.allowFlatten = !valueTransition.type && !valueTransition.ease;\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            return;\n        }\n    }\n    return valueTransition.isSync\n        ? new JSAnimation(options)\n        : new AsyncMotionValueAnimation(options);\n};\n\nexport { animateMotionValue };\n//# sourceMappingURL=motion-value.mjs.map\n"],"x_google_ignoreList":[0],"mappings":"+pBAUA,IAAM,GAAsB,EAAM,EAAO,EAAQ,EAAa,CAAC,EAAG,EAAS,IAAe,GAAe,CACrG,IAAM,EAAkBA,EAAAA,mBAAmB,EAAY,CAAI,GAAK,CAAC,EAM3D,EAAQ,EAAgB,OAAS,EAAW,OAAS,EAKvD,CAAE,UAAU,GAAM,EACtB,GAAoBC,EAAAA,sBAAsB,CAAK,EAC/C,IAAM,EAAU,CACZ,UAAW,MAAM,QAAQ,CAAM,EAAI,EAAS,CAAC,KAAM,CAAM,EACzD,KAAM,UACN,SAAU,EAAM,YAAY,EAC5B,GAAG,EACH,MAAO,CAAC,EACR,SAAW,GAAM,CACb,EAAM,IAAI,CAAC,EACX,EAAgB,UAAY,EAAgB,SAAS,CAAC,CAC1D,EACA,eAAkB,CACd,EAAW,EACX,EAAgB,YAAc,EAAgB,WAAW,CAC7D,EACA,OACA,YAAa,EACb,QAAS,EAAY,IAAA,GAAY,CACrC,EAKKC,EAAAA,oBAAoB,CAAe,GACpC,OAAO,OAAO,EAASC,EAAAA,qBAAqB,EAAM,CAAO,CAAC,EAO9D,AAAqB,EAAQ,WAAWF,EAAAA,sBAAsB,EAAQ,QAAQ,EAC9E,AAAwB,EAAQ,cAAcA,EAAAA,sBAAsB,EAAQ,WAAW,EAInF,EAAQ,OAAS,IAAA,KACjB,EAAQ,UAAU,GAAK,EAAQ,MAEnC,IAAI,EAAa,GA0BjB,IAzBI,EAAQ,OAAS,IAChB,EAAQ,WAAa,GAAK,CAAC,EAAQ,eACpC,EAAA,qBAAqB,CAAO,EACxB,EAAQ,QAAU,IAClB,EAAa,MAGjBG,EAAAA,mBAAmB,mBACnBA,EAAAA,mBAAmB,gBACnB,GAAS,sBACT,EAAgB,kBAChB,EAAa,GACb,EAAA,qBAAqB,CAAO,EAC5B,EAAQ,MAAQ,GAMpB,EAAQ,aAAe,CAAC,EAAgB,MAAQ,CAAC,EAAgB,KAM7D,GAAc,CAAC,GAAa,EAAM,IAAI,IAAM,IAAA,GAAW,CACvD,IAAM,EAAgBC,EAAAA,iBAAiB,EAAQ,UAAW,CAAe,EACzE,GAAI,IAAkB,IAAA,GAAW,CAC7B,EAAA,MAAM,WAAa,CACf,EAAQ,SAAS,CAAa,EAC9B,EAAQ,WAAW,CACvB,CAAC,EACD,MACJ,CACJ,CACA,OAAO,EAAgB,OACjB,IAAIC,EAAAA,YAAY,CAAO,EACvB,IAAIC,EAAAA,0BAA0B,CAAO,CAC/C"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"motion-value.es.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["import { secondsToMilliseconds, MotionGlobalConfig } from 'motion-utils';\nimport { AsyncMotionValueAnimation } from '../AsyncMotionValueAnimation.mjs';\nimport { JSAnimation } from '../JSAnimation.mjs';\nimport { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { makeAnimationInstant } from '../utils/make-animation-instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getFinalKeyframe } from '../keyframes/get-final.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    const options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unique transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        Object.assign(options, getDefaultTransition(name, options));\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    options.duration && (options.duration = secondsToMilliseconds(options.duration));\n    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));\n    /**\n     * Support deprecated way to set initial value. Prefer keyframe syntax.\n     */\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        makeAnimationInstant(options);\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (MotionGlobalConfig.instantAnimations ||\n        MotionGlobalConfig.skipAnimations ||\n        element?.shouldSkipAnimations ||\n        valueTransition.skipAnimations) {\n        shouldSkip = true;\n        makeAnimationInstant(options);\n        options.delay = 0;\n    }\n    /**\n     * If the transition type or easing has been explicitly set by the user\n     * then we don't want to allow flattening the animation.\n     */\n    options.allowFlatten = !valueTransition.type && !valueTransition.ease;\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            return;\n        }\n    }\n    return valueTransition.isSync\n        ? new JSAnimation(options)\n        : new AsyncMotionValueAnimation(options);\n};\n\nexport { animateMotionValue };\n//# sourceMappingURL=motion-value.mjs.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;AAUA,IAAM,KAAsB,GAAM,GAAO,GAAQ,IAAa,CAAC,GAAG,GAAS,OAAe,MAAe;CACrG,IAAM,IAAkB,EAAmB,GAAY,CAAI,KAAK,CAAC,GAM3D,IAAQ,EAAgB,SAAS,EAAW,SAAS,GAKvD,EAAE,aAAU,MAAM;CACtB,KAAoB,EAAsB,CAAK;CAC/C,IAAM,IAAU;EACZ,WAAW,MAAM,QAAQ,CAAM,IAAI,IAAS,CAAC,MAAM,CAAM;EACzD,MAAM;EACN,UAAU,EAAM,YAAY;EAC5B,GAAG;EACH,OAAO,CAAC;EACR,WAAW,MAAM;GAEb,AADA,EAAM,IAAI,CAAC,GACX,EAAgB,YAAY,EAAgB,SAAS,CAAC;EAC1D;EACA,kBAAkB;GAEd,AADA,EAAW,GACX,EAAgB,cAAc,EAAgB,WAAW;EAC7D;EACA;EACA,aAAa;EACb,SAAS,IAAY,KAAA,IAAY;CACrC;CAkBA,AAbK,EAAoB,CAAe,KACpC,OAAO,OAAO,GAAS,EAAqB,GAAM,CAAO,CAAC,GAO9D,AAAqB,EAAQ,aAAW,EAAsB,EAAQ,QAAQ,GAC9E,AAAwB,EAAQ,gBAAc,EAAsB,EAAQ,WAAW,GAInF,EAAQ,SAAS,KAAA,MACjB,EAAQ,UAAU,KAAK,EAAQ;CAEnC,IAAI,IAAa;CA0BjB,KAzBI,EAAQ,SAAS,MAChB,EAAQ,aAAa,KAAK,CAAC,EAAQ,iBACpC,EAAqB,CAAO,GACxB,EAAQ,UAAU,MAClB,IAAa,OAGjB,EAAmB,qBACnB,EAAmB,kBACnB,GAAS,wBACT,EAAgB,oBAChB,IAAa,IACb,EAAqB,CAAO,GAC5B,EAAQ,QAAQ,IAMpB,EAAQ,eAAe,CAAC,EAAgB,QAAQ,CAAC,EAAgB,MAM7D,KAAc,CAAC,KAAa,EAAM,IAAI,MAAM,KAAA,GAAW;EACvD,IAAM,IAAgB,EAAiB,EAAQ,WAAW,CAAe;EACzE,IAAI,MAAkB,KAAA,GAAW;GAC7B,EAAM,aAAa;IAEf,AADA,EAAQ,SAAS,CAAa,GAC9B,EAAQ,WAAW;GACvB,CAAC;GACD;EACJ;CACJ;CACA,OAAO,EAAgB,SACjB,IAAI,EAAY,CAAO,IACvB,IAAI,EAA0B,CAAO;AAC/C"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.cjs.js

@@ -1,2 +0,0 @@
-require("../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../../frameloop/frame.cjs.js"),t=require("../utils/resolve-transition.cjs.js"),n=require("../utils/get-value-transition.cjs.js"),r=require("./motion-value.cjs.js"),i=require("../../render/utils/keys-position.cjs.js"),a=require("../../render/utils/setters.cjs.js"),o=require("../../value/will-change/add-will-change.cjs.js"),s=require("../optimized-appear/get-appear-id.cjs.js");function c({protectedKeys:e,needsAnimating:t},n){let r=e.hasOwnProperty(n)&&t[n]!==!0;return t[n]=!1,r}function l(l,u,{delay:d=0,transitionOverride:f,type:p}={}){let{transition:m,transitionEnd:h,...g}=u,_=l.getDefaultTransition();m=m?t.resolveTransition(m,_):_;let v=m?.reduceMotion,y=m?.skipAnimations;f&&(m=f);let b=[],x=p&&l.animationState&&l.animationState.getState()[p],S=m?.path;S&&S.animateVisualElement(l,g,m,d,b);for(let t in g){let a=l.getValue(t,l.latestValues[t]??null),u=g[t];if(u===void 0||x&&c(x,t))continue;let f={delay:d,...n.getValueTransition(m||{},t)};y&&(f.skipAnimations=!0);let p=a.get();if(p!==void 0&&!a.isAnimating()&&!Array.isArray(u)&&u===p&&!f.velocity){e.frame.update(()=>a.set(u));continue}let h=!1;if(window.MotionHandoffAnimation){let n=s.getOptimisedAppearId(l);if(n){let r=window.MotionHandoffAnimation(n,t,e.frame);r!==null&&(f.startTime=r,h=!0)}}o.addValueToWillChange(l,t);let _=v??l.shouldReduceMotion;a.start(r.animateMotionValue(t,a,u,_&&i.positionalKeys.has(t)?{type:!1}:f,l,h));let S=a.animation;S&&b.push(S)}if(h){let t=()=>e.frame.update(()=>{h&&a.setTarget(l,h)});b.length?Promise.all(b).then(t):t()}return b}exports.animateTarget=l;
-//# sourceMappingURL=visual-element-target.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element-target.cjs.js","names":["resolveTransition","getValueTransition","getOptimisedAppearId","frame","animateMotionValue","positionalKeys","setTarget"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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    const skipAnimations = transition?.skipAnimations;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    const path = transition?.path;\n    if (path) {\n        // path mutates `target` to claim x/y; loop below skips them.\n        path.animateVisualElement(visualElement, target, transition, delay, animations);\n    }\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        if (skipAnimations)\n            valueTransition.skipAnimations = true;\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":"mdAeA,SAAS,EAAqB,CAAE,gBAAe,kBAAkB,EAAK,CAClE,IAAM,EAAc,EAAc,eAAe,CAAG,GAAK,EAAe,KAAS,GAEjF,MADA,GAAe,GAAO,GACf,CACX,CACA,SAAS,EAAc,EAAe,EAAqB,CAAE,QAAQ,EAAG,qBAAoB,QAAS,CAAC,EAAG,CACrG,GAAI,CAAE,aAAY,gBAAe,GAAG,GAAW,EACzC,EAAoB,EAAc,qBAAqB,EAC7D,EAAa,EACPA,EAAAA,kBAAkB,EAAY,CAAiB,EAC/C,EACN,IAAM,EAAe,GAAY,aAC3B,EAAiB,GAAY,eAC/B,IACA,EAAa,GACjB,IAAM,EAAa,CAAC,EACd,EAAqB,GACvB,EAAc,gBACd,EAAc,eAAe,SAAS,CAAC,CAAC,GACtC,EAAO,GAAY,KACrB,GAEA,EAAK,qBAAqB,EAAe,EAAQ,EAAY,EAAO,CAAU,EAElF,IAAK,IAAM,KAAO,EAAQ,CACtB,IAAM,EAAQ,EAAc,SAAS,EAAK,EAAc,aAAa,IAAQ,IAAI,EAC3E,EAAc,EAAO,GAC3B,GAAI,IAAgB,IAAA,IACf,GACG,EAAqB,EAAoB,CAAG,EAChD,SAEJ,IAAM,EAAkB,CACpB,QACA,GAAGC,EAAAA,mBAAmB,GAAc,CAAC,EAAG,CAAG,CAC/C,EACI,IACA,EAAgB,eAAiB,IAMrC,IAAM,EAAe,EAAM,IAAI,EAC/B,GAAI,IAAiB,IAAA,IACjB,CAAC,EAAM,YAAY,GACnB,CAAC,MAAM,QAAQ,CAAW,GAC1B,IAAgB,GAChB,CAAC,EAAgB,SAAU,CAC3B,EAAA,MAAM,WAAa,EAAM,IAAI,CAAW,CAAC,EACzC,QACJ,CAKA,IAAI,EAAY,GAChB,GAAI,OAAO,uBAAwB,CAC/B,IAAM,EAAWC,EAAAA,qBAAqB,CAAa,EACnD,GAAI,EAAU,CACV,IAAM,EAAY,OAAO,uBAAuB,EAAU,EAAKC,EAAAA,KAAK,EAChE,IAAc,OACd,EAAgB,UAAY,EAC5B,EAAY,GAEpB,CACJ,CACA,EAAA,qBAAqB,EAAe,CAAG,EACvC,IAAM,EAAqB,GAAgB,EAAc,mBACzD,EAAM,MAAMC,EAAAA,mBAAmB,EAAK,EAAO,EAAa,GAAsBC,EAAAA,eAAe,IAAI,CAAG,EAC9F,CAAE,KAAM,EAAM,EACd,EAAiB,EAAe,CAAS,CAAC,EAChD,IAAM,EAAY,EAAM,UACpB,GACA,EAAW,KAAK,CAAS,CAEjC,CACA,GAAI,EAAe,CACf,IAAM,MAA2BF,EAAAA,MAAM,WAAa,CAChD,GAAiBG,EAAAA,UAAU,EAAe,CAAa,CAC3D,CAAC,EACG,EAAW,OACX,QAAQ,IAAI,CAAU,CAAC,CAAC,KAAK,CAAkB,EAG/C,EAAmB,CAE3B,CACA,OAAO,CACX"}

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

@@ -1,59 +0,0 @@
-import { frame as e } from "../../frameloop/frame.es.js";
-import { resolveTransition as t } from "../utils/resolve-transition.es.js";
-import { getValueTransition as n } from "../utils/get-value-transition.es.js";
-import { animateMotionValue as r } from "./motion-value.es.js";
-import { positionalKeys as i } from "../../render/utils/keys-position.es.js";
-import { setTarget as a } from "../../render/utils/setters.es.js";
-import { addValueToWillChange as o } from "../../value/will-change/add-will-change.es.js";
-import { getOptimisedAppearId as s } from "../optimized-appear/get-appear-id.es.js";
-//#region ../../node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs
-function c({ protectedKeys: e, needsAnimating: t }, n) {
-	let r = e.hasOwnProperty(n) && t[n] !== !0;
-	return t[n] = !1, r;
-}
-function l(l, u, { delay: d = 0, transitionOverride: f, type: p } = {}) {
-	let { transition: m, transitionEnd: h, ...g } = u, _ = l.getDefaultTransition();
-	m = m ? t(m, _) : _;
-	let v = m?.reduceMotion, y = m?.skipAnimations;
-	f && (m = f);
-	let b = [], x = p && l.animationState && l.animationState.getState()[p], S = m?.path;
-	S && S.animateVisualElement(l, g, m, d, b);
-	for (let t in g) {
-		let a = l.getValue(t, l.latestValues[t] ?? null), u = g[t];
-		if (u === void 0 || x && c(x, t)) continue;
-		let f = {
-			delay: d,
-			...n(m || {}, t)
-		};
-		y && (f.skipAnimations = !0);
-		let p = a.get();
-		if (p !== void 0 && !a.isAnimating() && !Array.isArray(u) && u === p && !f.velocity) {
-			e.update(() => a.set(u));
-			continue;
-		}
-		let h = !1;
-		if (window.MotionHandoffAnimation) {
-			let n = s(l);
-			if (n) {
-				let r = window.MotionHandoffAnimation(n, t, e);
-				r !== null && (f.startTime = r, h = !0);
-			}
-		}
-		o(l, t);
-		let _ = v ?? l.shouldReduceMotion;
-		a.start(r(t, a, u, _ && i.has(t) ? { type: !1 } : f, l, h));
-		let S = a.animation;
-		S && b.push(S);
-	}
-	if (h) {
-		let t = () => e.update(() => {
-			h && a(l, h);
-		});
-		b.length ? Promise.all(b).then(t) : t();
-	}
-	return b;
-}
-//#endregion
-export { l as animateTarget };
-
-//# sourceMappingURL=visual-element-target.es.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element-target.es.js","names":[],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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    const skipAnimations = transition?.skipAnimations;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    const path = transition?.path;\n    if (path) {\n        // path mutates `target` to claim x/y; loop below skips them.\n        path.animateVisualElement(visualElement, target, transition, delay, animations);\n    }\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        if (skipAnimations)\n            valueTransition.skipAnimations = true;\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,EAAqB,EAAE,kBAAe,qBAAkB,GAAK;CAClE,IAAM,IAAc,EAAc,eAAe,CAAG,KAAK,EAAe,OAAS;CAEjF,OADA,EAAe,KAAO,IACf;AACX;AACA,SAAS,EAAc,GAAe,GAAqB,EAAE,WAAQ,GAAG,uBAAoB,YAAS,CAAC,GAAG;CACrG,IAAI,EAAE,eAAY,kBAAe,GAAG,MAAW,GACzC,IAAoB,EAAc,qBAAqB;CAC7D,IAAa,IACP,EAAkB,GAAY,CAAiB,IAC/C;CACN,IAAM,IAAe,GAAY,cAC3B,IAAiB,GAAY;CACnC,AAAI,MACA,IAAa;CACjB,IAAM,IAAa,CAAC,GACd,IAAqB,KACvB,EAAc,kBACd,EAAc,eAAe,SAAS,CAAC,CAAC,IACtC,IAAO,GAAY;CACzB,AAAI,KAEA,EAAK,qBAAqB,GAAe,GAAQ,GAAY,GAAO,CAAU;CAElF,KAAK,IAAM,KAAO,GAAQ;EACtB,IAAM,IAAQ,EAAc,SAAS,GAAK,EAAc,aAAa,MAAQ,IAAI,GAC3E,IAAc,EAAO;EAC3B,IAAI,MAAgB,KAAA,KACf,KACG,EAAqB,GAAoB,CAAG,GAChD;EAEJ,IAAM,IAAkB;GACpB;GACA,GAAG,EAAmB,KAAc,CAAC,GAAG,CAAG;EAC/C;EACA,AAAI,MACA,EAAgB,iBAAiB;EAMrC,IAAM,IAAe,EAAM,IAAI;EAC/B,IAAI,MAAiB,KAAA,KACjB,CAAC,EAAM,YAAY,KACnB,CAAC,MAAM,QAAQ,CAAW,KAC1B,MAAgB,KAChB,CAAC,EAAgB,UAAU;GAC3B,EAAM,aAAa,EAAM,IAAI,CAAW,CAAC;GACzC;EACJ;EAKA,IAAI,IAAY;EAChB,IAAI,OAAO,wBAAwB;GAC/B,IAAM,IAAW,EAAqB,CAAa;GACnD,IAAI,GAAU;IACV,IAAM,IAAY,OAAO,uBAAuB,GAAU,GAAK,CAAK;IACpE,AAAI,MAAc,SACd,EAAgB,YAAY,GAC5B,IAAY;GAEpB;EACJ;EACA,EAAqB,GAAe,CAAG;EACvC,IAAM,IAAqB,KAAgB,EAAc;EACzD,EAAM,MAAM,EAAmB,GAAK,GAAO,GAAa,KAAsB,EAAe,IAAI,CAAG,IAC9F,EAAE,MAAM,GAAM,IACd,GAAiB,GAAe,CAAS,CAAC;EAChD,IAAM,IAAY,EAAM;EACxB,AAAI,KACA,EAAW,KAAK,CAAS;CAEjC;CACA,IAAI,GAAe;EACf,IAAM,UAA2B,EAAM,aAAa;GAChD,KAAiB,EAAU,GAAe,CAAa;EAC3D,CAAC;EACD,AAAI,EAAW,SACX,QAAQ,IAAI,CAAU,CAAC,CAAC,KAAK,CAAkB,IAG/C,EAAmB;CAE3B;CACA,OAAO;AACX"}

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.cjs.js

@@ -1,2 +0,0 @@
-require("../../../../../../../../../_virtual/_rolldown/runtime.cjs.js");const e=require("../utils/calc-child-stagger.cjs.js"),t=require("../../render/utils/resolve-dynamic-variants.cjs.js"),n=require("./visual-element-target.cjs.js");function r(e,r,a={}){let o=t.resolveVariant(e,r,a.type===`exit`?e.presenceContext?.custom:void 0),{transition:s=e.getDefaultTransition()||{}}=o||{};a.transitionOverride&&(s=a.transitionOverride);let c=o?()=>Promise.all(n.animateTarget(e,o,a)):()=>Promise.resolve(),l=e.variantChildren&&e.variantChildren.size?(t=0)=>{let{delayChildren:n=0,staggerChildren:o,staggerDirection:c}=s;return i(e,r,t,n,o,c,a)}:()=>Promise.resolve(),{when:u}=s;if(u){let[e,t]=u===`beforeChildren`?[c,l]:[l,c];return e().then(()=>t())}else return Promise.all([c(),l(a.delay)])}function i(t,n,i=0,a=0,o=0,s=1,c){let l=[];for(let u of t.variantChildren)u.notify(`AnimationStart`,n),l.push(r(u,n,{...c,delay:i+(typeof a==`function`?0:a)+e.calcChildStagger(t.variantChildren,u,a,o,s)}).then(()=>u.notify(`AnimationComplete`,n)));return Promise.all(l)}exports.animateVariant=r;
-//# sourceMappingURL=visual-element-variant.cjs.js.map

package/dist/node_modules/.bun/motion-dom@12.42.2/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element-variant.cjs.js","names":["resolveVariant","animateTarget","calcChildStagger"],"sources":["../../../../../../../../../../../../node_modules/.bun/motion-dom@12.42.2/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":"0OAIA,SAAS,EAAe,EAAe,EAAS,EAAU,CAAC,EAAG,CAC1D,IAAM,EAAWA,EAAAA,eAAe,EAAe,EAAS,EAAQ,OAAS,OACnE,EAAc,iBAAiB,OAC/B,IAAA,EAAS,EACX,CAAE,aAAa,EAAc,qBAAqB,GAAK,CAAC,GAAM,GAAY,CAAC,EAC3E,EAAQ,qBACR,EAAa,EAAQ,oBAMzB,IAAM,EAAe,MACT,QAAQ,IAAIC,EAAAA,cAAc,EAAe,EAAU,CAAO,CAAC,MAC3D,QAAQ,QAAQ,EAKtB,EAAqB,EAAc,iBAAmB,EAAc,gBAAgB,MACnF,EAAe,IAAM,CACpB,GAAM,CAAE,gBAAgB,EAAG,kBAAiB,oBAAsB,EAClE,OAAO,EAAgB,EAAe,EAAS,EAAc,EAAe,EAAiB,EAAkB,CAAO,CAC1H,MACQ,QAAQ,QAAQ,EAKtB,CAAE,QAAS,EACjB,GAAI,EAAM,CACN,GAAM,CAAC,EAAO,GAAQ,IAAS,iBACzB,CAAC,EAAc,CAAkB,EACjC,CAAC,EAAoB,CAAY,EACvC,OAAO,EAAM,CAAC,CAAC,SAAW,EAAK,CAAC,CACpC,MAEI,OAAO,QAAQ,IAAI,CAAC,EAAa,EAAG,EAAmB,EAAQ,KAAK,CAAC,CAAC,CAE9E,CACA,SAAS,EAAgB,EAAe,EAAS,EAAQ,EAAG,EAAgB,EAAG,EAAkB,EAAG,EAAmB,EAAG,EAAS,CAC/H,IAAM,EAAa,CAAC,EACpB,IAAK,IAAM,KAAS,EAAc,gBAC9B,EAAM,OAAO,iBAAkB,CAAO,EACtC,EAAW,KAAK,EAAe,EAAO,EAAS,CAC3C,GAAG,EACH,MAAO,GACF,OAAO,GAAkB,WAAa,EAAI,GAC3CC,EAAAA,iBAAiB,EAAc,gBAAiB,EAAO,EAAe,EAAiB,CAAgB,CAC/G,CAAC,CAAC,CAAC,SAAW,EAAM,OAAO,oBAAqB,CAAO,CAAC,CAAC,EAE7D,OAAO,QAAQ,IAAI,CAAU,CACjC"}