@123usmanhaider321/ui 0.1.0 → 0.1.8

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

@@ -1,247 +0,0 @@
-import { generateLinearEasing } from "../waapi/utils/linear.js";
-import { calcGeneratorDuration, maxGeneratorDuration } from "./utils/calc-duration.js";
-import { createGeneratorEasing } from "./utils/create-generator-easing.js";
-import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../motion-utils/dist/es/time-conversion.js";
-import { clamp } from "../../../../../motion-utils/dist/es/clamp.js";
-import { warning } from "../../../../../motion-utils/dist/es/errors.js";
-const springDefaults = {
-  // Default spring physics
-  stiffness: 100,
-  damping: 10,
-  mass: 1,
-  velocity: 0,
-  // Default duration/bounce-based options
-  duration: 800,
-  // in ms
-  bounce: 0.3,
-  visualDuration: 0.3,
-  // in seconds
-  // Rest thresholds
-  restSpeed: {
-    granular: 0.01,
-    default: 2
-  },
-  restDelta: {
-    granular: 5e-3,
-    default: 0.5
-  },
-  // Limits
-  minDuration: 0.01,
-  // in seconds
-  maxDuration: 10,
-  // in seconds
-  minDamping: 0.05,
-  maxDamping: 1
-};
-function calcAngularFreq(undampedFreq, dampingRatio) {
-  return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
-}
-const rootIterations = 12;
-function approximateRoot(envelope, derivative, initialGuess) {
-  let result = initialGuess;
-  for (let i = 1; i < rootIterations; i++) {
-    result = result - envelope(result) / derivative(result);
-  }
-  return result;
-}
-const safeMin = 1e-3;
-function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
-  let envelope;
-  let derivative;
-  warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
-  let dampingRatio = 1 - bounce;
-  dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
-  duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));
-  if (dampingRatio < 1) {
-    envelope = (undampedFreq2) => {
-      const exponentialDecay = undampedFreq2 * dampingRatio;
-      const delta = exponentialDecay * duration;
-      const a = exponentialDecay - velocity;
-      const b = calcAngularFreq(undampedFreq2, dampingRatio);
-      const c = Math.exp(-delta);
-      return safeMin - a / b * c;
-    };
-    derivative = (undampedFreq2) => {
-      const exponentialDecay = undampedFreq2 * dampingRatio;
-      const delta = exponentialDecay * duration;
-      const d = delta * velocity + velocity;
-      const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq2, 2) * duration;
-      const f = Math.exp(-delta);
-      const g = calcAngularFreq(Math.pow(undampedFreq2, 2), dampingRatio);
-      const factor = -envelope(undampedFreq2) + safeMin > 0 ? -1 : 1;
-      return factor * ((d - e) * f) / g;
-    };
-  } else {
-    envelope = (undampedFreq2) => {
-      const a = Math.exp(-undampedFreq2 * duration);
-      const b = (undampedFreq2 - velocity) * duration + 1;
-      return -safeMin + a * b;
-    };
-    derivative = (undampedFreq2) => {
-      const a = Math.exp(-undampedFreq2 * duration);
-      const b = (velocity - undampedFreq2) * (duration * duration);
-      return a * b;
-    };
-  }
-  const initialGuess = 5 / duration;
-  const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
-  duration = secondsToMilliseconds(duration);
-  if (isNaN(undampedFreq)) {
-    return {
-      stiffness: springDefaults.stiffness,
-      damping: springDefaults.damping,
-      duration
-    };
-  } else {
-    const stiffness = Math.pow(undampedFreq, 2) * mass;
-    return {
-      stiffness,
-      damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
-      duration
-    };
-  }
-}
-const durationKeys = ["duration", "bounce"];
-const physicsKeys = ["stiffness", "damping", "mass"];
-function isSpringType(options, keys) {
-  return keys.some((key) => options[key] !== void 0);
-}
-function getSpringOptions(options) {
-  let springOptions = {
-    velocity: springDefaults.velocity,
-    stiffness: springDefaults.stiffness,
-    damping: springDefaults.damping,
-    mass: springDefaults.mass,
-    isResolvedFromDuration: false,
-    ...options
-  };
-  if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {
-    springOptions.velocity = 0;
-    if (options.visualDuration) {
-      const visualDuration = options.visualDuration;
-      const root = 2 * Math.PI / (visualDuration * 1.2);
-      const stiffness = root * root;
-      const damping = 2 * clamp(0.05, 1, 1 - (options.bounce || 0)) * Math.sqrt(stiffness);
-      springOptions = {
-        ...springOptions,
-        mass: springDefaults.mass,
-        stiffness,
-        damping
-      };
-    } else {
-      const derived = findSpring({ ...options, velocity: 0 });
-      springOptions = {
-        ...springOptions,
-        ...derived,
-        mass: springDefaults.mass
-      };
-      springOptions.isResolvedFromDuration = true;
-    }
-  }
-  return springOptions;
-}
-function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
-  const options = typeof optionsOrVisualDuration !== "object" ? {
-    visualDuration: optionsOrVisualDuration,
-    keyframes: [0, 1],
-    bounce
-  } : optionsOrVisualDuration;
-  let { restSpeed, restDelta } = options;
-  const origin = options.keyframes[0];
-  const target = options.keyframes[options.keyframes.length - 1];
-  const state = { done: false, value: origin };
-  const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
-    ...options,
-    velocity: -millisecondsToSeconds(options.velocity || 0)
-  });
-  const initialVelocity = velocity || 0;
-  const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
-  const initialDelta = target - origin;
-  const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
-  const isGranularScale = Math.abs(initialDelta) < 5;
-  restSpeed || (restSpeed = isGranularScale ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default);
-  restDelta || (restDelta = isGranularScale ? springDefaults.restDelta.granular : springDefaults.restDelta.default);
-  let resolveSpring;
-  let resolveVelocity;
-  let angularFreq;
-  let A;
-  let sinCoeff;
-  let cosCoeff;
-  if (dampingRatio < 1) {
-    angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
-    A = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq;
-    resolveSpring = (t) => {
-      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-      return target - envelope * (A * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));
-    };
-    sinCoeff = dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;
-    cosCoeff = dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;
-    resolveVelocity = (t) => {
-      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-      return envelope * (sinCoeff * Math.sin(angularFreq * t) + cosCoeff * Math.cos(angularFreq * t));
-    };
-  } else if (dampingRatio === 1) {
-    resolveSpring = (t) => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);
-    const C = initialVelocity + undampedAngularFreq * initialDelta;
-    resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) * (undampedAngularFreq * C * t - initialVelocity);
-  } else {
-    const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
-    resolveSpring = (t) => {
-      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-      const freqForT = Math.min(dampedAngularFreq * t, 300);
-      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
-    };
-    const P = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / dampedAngularFreq;
-    const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;
-    const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;
-    resolveVelocity = (t) => {
-      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-      const freqForT = Math.min(dampedAngularFreq * t, 300);
-      return envelope * (sinhCoeff * Math.sinh(freqForT) + coshCoeff * Math.cosh(freqForT));
-    };
-  }
-  const generator = {
-    calculatedDuration: isResolvedFromDuration ? duration || null : null,
-    velocity: (t) => secondsToMilliseconds(resolveVelocity(t)),
-    next: (t) => {
-      if (!isResolvedFromDuration && dampingRatio < 1) {
-        const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-        const sin = Math.sin(angularFreq * t);
-        const cos = Math.cos(angularFreq * t);
-        const current2 = target - envelope * (A * sin + initialDelta * cos);
-        const currentVelocity = secondsToMilliseconds(envelope * (sinCoeff * sin + cosCoeff * cos));
-        state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current2) <= restDelta;
-        state.value = state.done ? target : current2;
-        return state;
-      }
-      const current = resolveSpring(t);
-      if (!isResolvedFromDuration) {
-        const currentVelocity = secondsToMilliseconds(resolveVelocity(t));
-        state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current) <= restDelta;
-      } else {
-        state.done = t >= duration;
-      }
-      state.value = state.done ? target : current;
-      return state;
-    },
-    toString: () => {
-      const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
-      const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);
-      return calculatedDuration + "ms " + easing;
-    },
-    toTransition: () => {
-    }
-  };
-  return generator;
-}
-spring.applyToOptions = (options) => {
-  const generatorOptions = createGeneratorEasing(options, 100, spring);
-  options.ease = generatorOptions.ease;
-  options.duration = secondsToMilliseconds(generatorOptions.duration);
-  options.type = "keyframes";
-  return options;
-};
-export {
-  spring
-};
-//# sourceMappingURL=spring.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"spring.js","sources":["../../../../../../../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"],"names":["undampedFreq","current"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,16 +0,0 @@
-const maxGeneratorDuration = 2e4;
-function calcGeneratorDuration(generator) {
-  let duration = 0;
-  const timeStep = 50;
-  let state = generator.next(duration);
-  while (!state.done && duration < maxGeneratorDuration) {
-    duration += timeStep;
-    state = generator.next(duration);
-  }
-  return duration >= maxGeneratorDuration ? Infinity : duration;
-}
-export {
-  calcGeneratorDuration,
-  maxGeneratorDuration
-};
-//# sourceMappingURL=calc-duration.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"calc-duration.js","sources":["../../../../../../../../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"],"names":[],"mappings":"AAIK,MAAC,uBAAuB;AAC7B,SAAS,sBAAsB,WAAW;AACtC,MAAI,WAAW;AACf,QAAM,WAAW;AACjB,MAAI,QAAQ,UAAU,KAAK,QAAQ;AACnC,SAAO,CAAC,MAAM,QAAQ,WAAW,sBAAsB;AACnD,gBAAY;AACZ,YAAQ,UAAU,KAAK,QAAQ;AAAA,EACnC;AACA,SAAO,YAAY,uBAAuB,WAAW;AACzD;","x_google_ignoreList":[0]}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"create-generator-easing.js","sources":["../../../../../../../../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"],"names":[],"mappings":";;AAMA,SAAS,sBAAsB,SAAS,QAAQ,KAAK,iBAAiB;AAClE,QAAM,YAAY,gBAAgB,EAAE,GAAG,SAAS,WAAW,CAAC,GAAG,KAAK,GAAG;AACvE,QAAM,WAAW,KAAK,IAAI,sBAAsB,SAAS,GAAG,oBAAoB;AAChF,SAAO;AAAA,IACH,MAAM;AAAA,IACN,MAAM,CAAC,aAAa;AAChB,aAAO,UAAU,KAAK,WAAW,QAAQ,EAAE,QAAQ;AAAA,IACvD;AAAA,IACA,UAAU,sBAAsB,QAAQ;AAAA,EAChD;AACA;","x_google_ignoreList":[0]}

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

@@ -1,7 +0,0 @@
-function isGenerator(type) {
-  return typeof type === "function" && "applyToOptions" in type;
-}
-export {
-  isGenerator
-};
-//# sourceMappingURL=is-generator.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-generator.js","sources":["../../../../../../../../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"],"names":[],"mappings":"AAAA,SAAS,YAAY,MAAM;AACvB,SAAO,OAAO,SAAS,cAAc,oBAAoB;AAC7D;","x_google_ignoreList":[0]}

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

@@ -1,10 +0,0 @@
-import { velocityPerSecond } from "../../../../../../motion-utils/dist/es/velocity-per-second.js";
-const velocitySampleDuration = 5;
-function getGeneratorVelocity(resolveValue, t, current) {
-  const prevT = Math.max(t - velocitySampleDuration, 0);
-  return velocityPerSecond(current - resolveValue(prevT), t - prevT);
-}
-export {
-  getGeneratorVelocity
-};
-//# sourceMappingURL=velocity.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"velocity.js","sources":["../../../../../../../../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"],"names":[],"mappings":";AAEA,MAAM,yBAAyB;AAC/B,SAAS,qBAAqB,cAAc,GAAG,SAAS;AACpD,QAAM,QAAQ,KAAK,IAAI,IAAI,wBAAwB,CAAC;AACpD,SAAO,kBAAkB,UAAU,aAAa,KAAK,GAAG,IAAI,KAAK;AACrE;","x_google_ignoreList":[0]}

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

@@ -1,70 +0,0 @@
-import { AsyncMotionValueAnimation } from "../AsyncMotionValueAnimation.js";
-import { JSAnimation } from "../JSAnimation.js";
-import { getValueTransition } from "../utils/get-value-transition.js";
-import { makeAnimationInstant } from "../utils/make-animation-instant.js";
-import { getDefaultTransition } from "../utils/default-transitions.js";
-import { getFinalKeyframe } from "../keyframes/get-final.js";
-import { isTransitionDefined } from "../utils/is-transition-defined.js";
-import { frame } from "../../frameloop/frame.js";
-import { secondsToMilliseconds } from "../../../../../motion-utils/dist/es/time-conversion.js";
-import { MotionGlobalConfig } from "../../../../../motion-utils/dist/es/global-config.js";
-const animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
-  const valueTransition = getValueTransition(transition, name) || {};
-  const delay = valueTransition.delay || transition.delay || 0;
-  let { elapsed = 0 } = transition;
-  elapsed = elapsed - secondsToMilliseconds(delay);
-  const options = {
-    keyframes: Array.isArray(target) ? target : [null, target],
-    ease: "easeOut",
-    velocity: value.getVelocity(),
-    ...valueTransition,
-    delay: -elapsed,
-    onUpdate: (v) => {
-      value.set(v);
-      valueTransition.onUpdate && valueTransition.onUpdate(v);
-    },
-    onComplete: () => {
-      onComplete();
-      valueTransition.onComplete && valueTransition.onComplete();
-    },
-    name,
-    motionValue: value,
-    element: isHandoff ? void 0 : element
-  };
-  if (!isTransitionDefined(valueTransition)) {
-    Object.assign(options, getDefaultTransition(name, options));
-  }
-  options.duration && (options.duration = secondsToMilliseconds(options.duration));
-  options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));
-  if (options.from !== void 0) {
-    options.keyframes[0] = options.from;
-  }
-  let shouldSkip = false;
-  if (options.type === false || options.duration === 0 && !options.repeatDelay) {
-    makeAnimationInstant(options);
-    if (options.delay === 0) {
-      shouldSkip = true;
-    }
-  }
-  if (MotionGlobalConfig.instantAnimations || MotionGlobalConfig.skipAnimations || (element == null ? void 0 : element.shouldSkipAnimations)) {
-    shouldSkip = true;
-    makeAnimationInstant(options);
-    options.delay = 0;
-  }
-  options.allowFlatten = !valueTransition.type && !valueTransition.ease;
-  if (shouldSkip && !isHandoff && value.get() !== void 0) {
-    const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);
-    if (finalKeyframe !== void 0) {
-      frame.update(() => {
-        options.onUpdate(finalKeyframe);
-        options.onComplete();
-      });
-      return;
-    }
-  }
-  return valueTransition.isSync ? new JSAnimation(options) : new AsyncMotionValueAnimation(options);
-};
-export {
-  animateMotionValue
-};
-//# sourceMappingURL=motion-value.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"motion-value.js","sources":["../../../../../../../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"],"names":[],"mappings":";;;;;;;;;;AAUK,MAAC,qBAAqB,CAAC,MAAM,OAAO,QAAQ,aAAa,CAAA,GAAI,SAAS,cAAc,CAAC,eAAe;AACrG,QAAM,kBAAkB,mBAAmB,YAAY,IAAI,KAAK,CAAA;AAMhE,QAAM,QAAQ,gBAAgB,SAAS,WAAW,SAAS;AAK3D,MAAI,EAAE,UAAU,EAAC,IAAK;AACtB,YAAU,UAAU,sBAAsB,KAAK;AAC/C,QAAM,UAAU;AAAA,IACZ,WAAW,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAM,MAAM;AAAA,IACzD,MAAM;AAAA,IACN,UAAU,MAAM,YAAW;AAAA,IAC3B,GAAG;AAAA,IACH,OAAO,CAAC;AAAA,IACR,UAAU,CAAC,MAAM;AACb,YAAM,IAAI,CAAC;AACX,sBAAgB,YAAY,gBAAgB,SAAS,CAAC;AAAA,IAC1D;AAAA,IACA,YAAY,MAAM;AACd,iBAAU;AACV,sBAAgB,cAAc,gBAAgB,WAAU;AAAA,IAC5D;AAAA,IACA;AAAA,IACA,aAAa;AAAA,IACb,SAAS,YAAY,SAAY;AAAA,EACzC;AAKI,MAAI,CAAC,oBAAoB,eAAe,GAAG;AACvC,WAAO,OAAO,SAAS,qBAAqB,MAAM,OAAO,CAAC;AAAA,EAC9D;AAMA,UAAQ,aAAa,QAAQ,WAAW,sBAAsB,QAAQ,QAAQ;AAC9E,UAAQ,gBAAgB,QAAQ,cAAc,sBAAsB,QAAQ,WAAW;AAIvF,MAAI,QAAQ,SAAS,QAAW;AAC5B,YAAQ,UAAU,CAAC,IAAI,QAAQ;AAAA,EACnC;AACA,MAAI,aAAa;AACjB,MAAI,QAAQ,SAAS,SAChB,QAAQ,aAAa,KAAK,CAAC,QAAQ,aAAc;AAClD,yBAAqB,OAAO;AAC5B,QAAI,QAAQ,UAAU,GAAG;AACrB,mBAAa;AAAA,IACjB;AAAA,EACJ;AACA,MAAI,mBAAmB,qBACnB,mBAAmB,mBACnB,mCAAS,uBAAsB;AAC/B,iBAAa;AACb,yBAAqB,OAAO;AAC5B,YAAQ,QAAQ;AAAA,EACpB;AAKA,UAAQ,eAAe,CAAC,gBAAgB,QAAQ,CAAC,gBAAgB;AAMjE,MAAI,cAAc,CAAC,aAAa,MAAM,IAAG,MAAO,QAAW;AACvD,UAAM,gBAAgB,iBAAiB,QAAQ,WAAW,eAAe;AACzE,QAAI,kBAAkB,QAAW;AAC7B,YAAM,OAAO,MAAM;AACf,gBAAQ,SAAS,aAAa;AAC9B,gBAAQ,WAAU;AAAA,MACtB,CAAC;AACD;AAAA,IACJ;AAAA,EACJ;AACA,SAAO,gBAAgB,SACjB,IAAI,YAAY,OAAO,IACvB,IAAI,0BAA0B,OAAO;AAC/C;","x_google_ignoreList":[0]}

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

@@ -1,72 +0,0 @@
-import { getValueTransition } from "../utils/get-value-transition.js";
-import { resolveTransition } from "../utils/resolve-transition.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";
-import { animateMotionValue } from "./motion-value.js";
-import { frame } from "../../frameloop/frame.js";
-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 == null ? void 0 : 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)
-    };
-    const currentValue = value.get();
-    if (currentValue !== void 0 && !value.isAnimating() && !Array.isArray(valueTarget) && valueTarget === currentValue && !valueTransition.velocity) {
-      frame.update(() => value.set(valueTarget));
-      continue;
-    }
-    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;
-}
-export {
-  animateTarget
-};
-//# sourceMappingURL=visual-element-target.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element-target.js","sources":["../../../../../../../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"],"names":[],"mappings":";;;;;;;;AAeA,SAAS,qBAAqB,EAAE,eAAe,eAAc,GAAI,KAAK;AAClE,QAAM,cAAc,cAAc,eAAe,GAAG,KAAK,eAAe,GAAG,MAAM;AACjF,iBAAe,GAAG,IAAI;AACtB,SAAO;AACX;AACA,SAAS,cAAc,eAAe,qBAAqB,EAAE,QAAQ,GAAG,oBAAoB,KAAI,IAAK,IAAI;AACrG,MAAI,EAAE,YAAY,eAAe,GAAG,OAAM,IAAK;AAC/C,QAAM,oBAAoB,cAAc,qBAAoB;AAC5D,eAAa,aACP,kBAAkB,YAAY,iBAAiB,IAC/C;AACN,QAAM,eAAe,yCAAY;AACjC,MAAI;AACA,iBAAa;AACjB,QAAM,aAAa,CAAA;AACnB,QAAM,qBAAqB,QACvB,cAAc,kBACd,cAAc,eAAe,SAAQ,EAAG,IAAI;AAChD,aAAW,OAAO,QAAQ;AACtB,UAAM,QAAQ,cAAc,SAAS,KAAK,cAAc,aAAa,GAAG,KAAK,IAAI;AACjF,UAAM,cAAc,OAAO,GAAG;AAC9B,QAAI,gBAAgB,UACf,sBACG,qBAAqB,oBAAoB,GAAG,GAAI;AACpD;AAAA,IACJ;AACA,UAAM,kBAAkB;AAAA,MACpB;AAAA,MACA,GAAG,mBAAmB,cAAc,CAAA,GAAI,GAAG;AAAA,IACvD;AAMQ,UAAM,eAAe,MAAM,IAAG;AAC9B,QAAI,iBAAiB,UACjB,CAAC,MAAM,YAAW,KAClB,CAAC,MAAM,QAAQ,WAAW,KAC1B,gBAAgB,gBAChB,CAAC,gBAAgB,UAAU;AAC3B,YAAM,OAAO,MAAM,MAAM,IAAI,WAAW,CAAC;AACzC;AAAA,IACJ;AAKA,QAAI,YAAY;AAChB,QAAI,OAAO,wBAAwB;AAC/B,YAAM,WAAW,qBAAqB,aAAa;AACnD,UAAI,UAAU;AACV,cAAM,YAAY,OAAO,uBAAuB,UAAU,KAAK,KAAK;AACpE,YAAI,cAAc,MAAM;AACpB,0BAAgB,YAAY;AAC5B,sBAAY;AAAA,QAChB;AAAA,MACJ;AAAA,IACJ;AACA,yBAAqB,eAAe,GAAG;AACvC,UAAM,qBAAqB,gBAAgB,cAAc;AACzD,UAAM,MAAM,mBAAmB,KAAK,OAAO,aAAa,sBAAsB,eAAe,IAAI,GAAG,IAC9F,EAAE,MAAM,MAAK,IACb,iBAAiB,eAAe,SAAS,CAAC;AAChD,UAAM,YAAY,MAAM;AACxB,QAAI,WAAW;AACX,iBAAW,KAAK,SAAS;AAAA,IAC7B;AAAA,EACJ;AACA,MAAI,eAAe;AACf,UAAM,qBAAqB,MAAM,MAAM,OAAO,MAAM;AAChD,uBAAiB,UAAU,eAAe,aAAa;AAAA,IAC3D,CAAC;AACD,QAAI,WAAW,QAAQ;AACnB,cAAQ,IAAI,UAAU,EAAE,KAAK,kBAAkB;AAAA,IACnD,OACK;AACD,yBAAkB;AAAA,IACtB;AAAA,EACJ;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

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

@@ -1,38 +0,0 @@
-import { resolveVariant } from "../../render/utils/resolve-dynamic-variants.js";
-import { calcChildStagger } from "../utils/calc-child-stagger.js";
-import { animateTarget } from "./visual-element-target.js";
-function animateVariant(visualElement, variant, options = {}) {
-  var _a;
-  const resolved = resolveVariant(visualElement, variant, options.type === "exit" ? (_a = visualElement.presenceContext) == null ? void 0 : _a.custom : void 0);
-  let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
-  if (options.transitionOverride) {
-    transition = options.transitionOverride;
-  }
-  const getAnimation = resolved ? () => Promise.all(animateTarget(visualElement, resolved, options)) : () => Promise.resolve();
-  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();
-  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);
-}
-export {
-  animateVariant
-};
-//# sourceMappingURL=visual-element-variant.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element-variant.js","sources":["../../../../../../../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"],"names":[],"mappings":";;;AAIA,SAAS,eAAe,eAAe,SAAS,UAAU,CAAA,GAAI;;AAC1D,QAAM,WAAW,eAAe,eAAe,SAAS,QAAQ,SAAS,UACnE,mBAAc,oBAAd,mBAA+B,SAC/B,MAAS;AACf,MAAI,EAAE,aAAa,cAAc,qBAAoB,KAAM,CAAA,EAAE,IAAK,YAAY,CAAA;AAC9E,MAAI,QAAQ,oBAAoB;AAC5B,iBAAa,QAAQ;AAAA,EACzB;AAKA,QAAM,eAAe,WACf,MAAM,QAAQ,IAAI,cAAc,eAAe,UAAU,OAAO,CAAC,IACjE,MAAM,QAAQ,QAAO;AAK3B,QAAM,qBAAqB,cAAc,mBAAmB,cAAc,gBAAgB,OACpF,CAAC,eAAe,MAAM;AACpB,UAAM,EAAE,gBAAgB,GAAG,iBAAiB,iBAAgB,IAAM;AAClE,WAAO,gBAAgB,eAAe,SAAS,cAAc,eAAe,iBAAiB,kBAAkB,OAAO;AAAA,EAC1H,IACE,MAAM,QAAQ,QAAO;AAK3B,QAAM,EAAE,KAAI,IAAK;AACjB,MAAI,MAAM;AACN,UAAM,CAAC,OAAO,IAAI,IAAI,SAAS,mBACzB,CAAC,cAAc,kBAAkB,IACjC,CAAC,oBAAoB,YAAY;AACvC,WAAO,MAAK,EAAG,KAAK,MAAM,KAAI,CAAE;AAAA,EACpC,OACK;AACD,WAAO,QAAQ,IAAI,CAAC,aAAY,GAAI,mBAAmB,QAAQ,KAAK,CAAC,CAAC;AAAA,EAC1E;AACJ;AACA,SAAS,gBAAgB,eAAe,SAAS,QAAQ,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,mBAAmB,GAAG,SAAS;AAC/H,QAAM,aAAa,CAAA;AACnB,aAAW,SAAS,cAAc,iBAAiB;AAC/C,UAAM,OAAO,kBAAkB,OAAO;AACtC,eAAW,KAAK,eAAe,OAAO,SAAS;AAAA,MAC3C,GAAG;AAAA,MACH,OAAO,SACF,OAAO,kBAAkB,aAAa,IAAI,iBAC3C,iBAAiB,cAAc,iBAAiB,OAAO,eAAe,iBAAiB,gBAAgB;AAAA,IACvH,CAAS,EAAE,KAAK,MAAM,MAAM,OAAO,qBAAqB,OAAO,CAAC,CAAC;AAAA,EAC7D;AACA,SAAO,QAAQ,IAAI,UAAU;AACjC;","x_google_ignoreList":[0]}

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

@@ -1,23 +0,0 @@
-import { resolveVariant } from "../../render/utils/resolve-dynamic-variants.js";
-import { animateTarget } from "./visual-element-target.js";
-import { animateVariant } from "./visual-element-variant.js";
-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);
-  });
-}
-export {
-  animateVisualElement
-};
-//# sourceMappingURL=visual-element.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"visual-element.js","sources":["../../../../../../../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"],"names":[],"mappings":";;;AAIA,SAAS,qBAAqB,eAAe,YAAY,UAAU,CAAA,GAAI;AACnE,gBAAc,OAAO,kBAAkB,UAAU;AACjD,MAAI;AACJ,MAAI,MAAM,QAAQ,UAAU,GAAG;AAC3B,UAAM,aAAa,WAAW,IAAI,CAAC,YAAY,eAAe,eAAe,SAAS,OAAO,CAAC;AAC9F,gBAAY,QAAQ,IAAI,UAAU;AAAA,EACtC,WACS,OAAO,eAAe,UAAU;AACrC,gBAAY,eAAe,eAAe,YAAY,OAAO;AAAA,EACjE,OACK;AACD,UAAM,qBAAqB,OAAO,eAAe,aAC3C,eAAe,eAAe,YAAY,QAAQ,MAAM,IACxD;AACN,gBAAY,QAAQ,IAAI,cAAc,eAAe,oBAAoB,OAAO,CAAC;AAAA,EACrF;AACA,SAAO,UAAU,KAAK,MAAM;AACxB,kBAAc,OAAO,qBAAqB,UAAU;AAAA,EACxD,CAAC;AACL;","x_google_ignoreList":[0]}