motion-v 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/es/external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs

@@ -0,0 +1,281 @@
+import { invariant } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
+import { calcGeneratorDuration } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs";
+import { isGenerator } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/is-generator.mjs";
+import { KeyframeResolver } from "../../render/utils/KeyframesResolver.mjs";
+import { clamp } from "../../utils/clamp.mjs";
+import { mix } from "../../utils/mix/index.mjs";
+import { pipe } from "../../utils/pipe.mjs";
+import { inertia } from "../generators/inertia.mjs";
+import { keyframes } from "../generators/keyframes.mjs";
+import { spring } from "../generators/spring/index.mjs";
+import { BaseAnimation } from "./BaseAnimation.mjs";
+import { frameloopDriver } from "./drivers/driver-frameloop.mjs";
+import { getFinalKeyframe } from "./waapi/utils/get-final-keyframe.mjs";
+const generators = {
+  decay: inertia,
+  inertia,
+  tween: keyframes,
+  keyframes,
+  spring
+};
+const percentToProgress = (percent) => percent / 100;
+class MainThreadAnimation extends BaseAnimation {
+  constructor(options) {
+    super(options);
+    this.holdTime = null;
+    this.cancelTime = null;
+    this.currentTime = 0;
+    this.playbackSpeed = 1;
+    this.pendingPlayState = "running";
+    this.startTime = null;
+    this.state = "idle";
+    this.stop = () => {
+      this.resolver.cancel();
+      this.isStopped = true;
+      if (this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop } = this.options;
+      onStop && onStop();
+    };
+    const { name, motionValue, element, keyframes: keyframes2 } = this.options;
+    const KeyframeResolver$1 = (element === null || element === void 0 ? void 0 : element.KeyframeResolver) || KeyframeResolver;
+    const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);
+    this.resolver = new KeyframeResolver$1(keyframes2, onResolved, name, motionValue, element);
+    this.resolver.scheduleResolve();
+  }
+  flatten() {
+    super.flatten();
+    if (this._resolved) {
+      Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
+    }
+  }
+  initPlayback(keyframes$1) {
+    const { type = "keyframes", repeat = 0, repeatDelay = 0, repeatType, velocity = 0 } = this.options;
+    const generatorFactory = isGenerator(type) ? type : generators[type] || keyframes;
+    let mapPercentToKeyframes;
+    let mirroredGenerator;
+    if (process.env.NODE_ENV !== "production" && generatorFactory !== keyframes) {
+      invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);
+    }
+    if (generatorFactory !== keyframes && typeof keyframes$1[0] !== "number") {
+      mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));
+      keyframes$1 = [0, 100];
+    }
+    const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });
+    if (repeatType === "mirror") {
+      mirroredGenerator = generatorFactory({
+        ...this.options,
+        keyframes: [...keyframes$1].reverse(),
+        velocity: -velocity
+      });
+    }
+    if (generator.calculatedDuration === null) {
+      generator.calculatedDuration = calcGeneratorDuration(generator);
+    }
+    const { calculatedDuration } = generator;
+    const resolvedDuration = calculatedDuration + repeatDelay;
+    const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;
+    return {
+      generator,
+      mirroredGenerator,
+      mapPercentToKeyframes,
+      calculatedDuration,
+      resolvedDuration,
+      totalDuration
+    };
+  }
+  onPostResolved() {
+    const { autoplay = true } = this.options;
+    this.play();
+    if (this.pendingPlayState === "paused" || !autoplay) {
+      this.pause();
+    } else {
+      this.state = this.pendingPlayState;
+    }
+  }
+  tick(timestamp, sample = false) {
+    const { resolved } = this;
+    if (!resolved) {
+      const { keyframes: keyframes3 } = this.options;
+      return { done: true, value: keyframes3[keyframes3.length - 1] };
+    }
+    const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes: keyframes2, calculatedDuration, totalDuration, resolvedDuration } = resolved;
+    if (this.startTime === null)
+      return generator.next(0);
+    const { delay, repeat, repeatType, repeatDelay, onUpdate } = this.options;
+    if (this.speed > 0) {
+      this.startTime = Math.min(this.startTime, timestamp);
+    } else if (this.speed < 0) {
+      this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);
+    }
+    if (sample) {
+      this.currentTime = timestamp;
+    } else if (this.holdTime !== null) {
+      this.currentTime = this.holdTime;
+    } else {
+      this.currentTime = Math.round(timestamp - this.startTime) * this.speed;
+    }
+    const timeWithoutDelay = this.currentTime - delay * (this.speed >= 0 ? 1 : -1);
+    const isInDelayPhase = this.speed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;
+    this.currentTime = Math.max(timeWithoutDelay, 0);
+    if (this.state === "finished" && this.holdTime === null) {
+      this.currentTime = totalDuration;
+    }
+    let elapsed = this.currentTime;
+    let frameGenerator = generator;
+    if (repeat) {
+      const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;
+      let currentIteration = Math.floor(progress);
+      let iterationProgress = progress % 1;
+      if (!iterationProgress && progress >= 1) {
+        iterationProgress = 1;
+      }
+      iterationProgress === 1 && currentIteration--;
+      currentIteration = Math.min(currentIteration, repeat + 1);
+      const isOddIteration = Boolean(currentIteration % 2);
+      if (isOddIteration) {
+        if (repeatType === "reverse") {
+          iterationProgress = 1 - iterationProgress;
+          if (repeatDelay) {
+            iterationProgress -= repeatDelay / resolvedDuration;
+          }
+        } else if (repeatType === "mirror") {
+          frameGenerator = mirroredGenerator;
+        }
+      }
+      elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;
+    }
+    const state = isInDelayPhase ? { done: false, value: keyframes2[0] } : frameGenerator.next(elapsed);
+    if (mapPercentToKeyframes) {
+      state.value = mapPercentToKeyframes(state.value);
+    }
+    let { done } = state;
+    if (!isInDelayPhase && calculatedDuration !== null) {
+      done = this.speed >= 0 ? this.currentTime >= totalDuration : this.currentTime <= 0;
+    }
+    const isAnimationFinished = this.holdTime === null && (this.state === "finished" || this.state === "running" && done);
+    if (isAnimationFinished && finalKeyframe !== void 0) {
+      state.value = getFinalKeyframe(keyframes2, this.options, finalKeyframe);
+    }
+    if (onUpdate) {
+      onUpdate(state.value);
+    }
+    if (isAnimationFinished) {
+      this.finish();
+    }
+    return state;
+  }
+  get duration() {
+    const { resolved } = this;
+    return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;
+  }
+  get time() {
+    return millisecondsToSeconds(this.currentTime);
+  }
+  set time(newTime) {
+    newTime = secondsToMilliseconds(newTime);
+    this.currentTime = newTime;
+    if (this.holdTime !== null || this.speed === 0) {
+      this.holdTime = newTime;
+    } else if (this.driver) {
+      this.startTime = this.driver.now() - newTime / this.speed;
+    }
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(newSpeed) {
+    const hasChanged = this.playbackSpeed !== newSpeed;
+    this.playbackSpeed = newSpeed;
+    if (hasChanged) {
+      this.time = millisecondsToSeconds(this.currentTime);
+    }
+  }
+  play() {
+    if (!this.resolver.isScheduled) {
+      this.resolver.resume();
+    }
+    if (!this._resolved) {
+      this.pendingPlayState = "running";
+      return;
+    }
+    if (this.isStopped)
+      return;
+    const { driver = frameloopDriver, onPlay, startTime } = this.options;
+    if (!this.driver) {
+      this.driver = driver((timestamp) => this.tick(timestamp));
+    }
+    onPlay && onPlay();
+    const now = this.driver.now();
+    if (this.holdTime !== null) {
+      this.startTime = now - this.holdTime;
+    } else if (!this.startTime) {
+      this.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
+    } else if (this.state === "finished") {
+      this.startTime = now;
+    }
+    if (this.state === "finished") {
+      this.updateFinishedPromise();
+    }
+    this.cancelTime = this.startTime;
+    this.holdTime = null;
+    this.state = "running";
+    this.driver.start();
+  }
+  pause() {
+    var _a;
+    if (!this._resolved) {
+      this.pendingPlayState = "paused";
+      return;
+    }
+    this.state = "paused";
+    this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;
+  }
+  complete() {
+    if (this.state !== "running") {
+      this.play();
+    }
+    this.pendingPlayState = this.state = "finished";
+    this.holdTime = null;
+  }
+  finish() {
+    this.teardown();
+    this.state = "finished";
+    const { onComplete } = this.options;
+    onComplete && onComplete();
+  }
+  cancel() {
+    if (this.cancelTime !== null) {
+      this.tick(this.cancelTime);
+    }
+    this.teardown();
+    this.updateFinishedPromise();
+  }
+  teardown() {
+    this.state = "idle";
+    this.stopDriver();
+    this.resolveFinishedPromise();
+    this.updateFinishedPromise();
+    this.startTime = this.cancelTime = null;
+    this.resolver.cancel();
+  }
+  stopDriver() {
+    if (!this.driver)
+      return;
+    this.driver.stop();
+    this.driver = void 0;
+  }
+  sample(time) {
+    this.startTime = 0;
+    return this.tick(time, true);
+  }
+}
+function animateValue(options) {
+  return new MainThreadAnimation(options);
+}
+export {
+  MainThreadAnimation,
+  animateValue
+};

package/dist/es/external/.pnpm/{motion-dom@12.9.0/external/motion-dom/dist/es/animation → framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators}/drivers/driver-frameloop.mjs

@@ -1,5 +1,6 @@
-import { time } from "../../frameloop/sync-time.mjs";
-import { frame, cancelFrame, frameData } from "../../frameloop/frame.mjs";
+import "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { frame, cancelFrame, frameData } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/frame.mjs";
+import { time } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/sync-time.mjs";
 const frameloopDriver = (update) => {
   const passTimestamp = ({ timestamp }) => update(timestamp);
   return {

package/dist/es/external/.pnpm/{motion-dom@12.9.0/external/motion-dom/dist/es/animation → framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators}/utils/can-animate.mjs

@@ -1,6 +1,6 @@
-import { isGenerator } from "../generators/utils/is-generator.mjs";
-import { isAnimatable } from "./is-animatable.mjs";
-import { warning } from "../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/errors.mjs";
+import { warning } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { isGenerator } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/is-generator.mjs";
+import { isAnimatable } from "../../utils/is-animatable.mjs";
 function hasKeyframesChanged(keyframes) {
   const current = keyframes[0];
   if (keyframes.length === 1)

package/dist/es/external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/waapi/NativeAnimation.mjs

@@ -0,0 +1,108 @@
+import { invariant } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { secondsToMilliseconds } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
+import { createGeneratorEasing } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs";
+import { isGenerator } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/is-generator.mjs";
+import { NativeAnimationControls } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/NativeAnimationControls.mjs";
+import { supportsLinearEasing } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/utils/supports/linear-easing.mjs";
+import { startWaapiAnimation } from "./index.mjs";
+import { browserNumberValueTypes } from "../../../render/dom/value-types/number-browser.mjs";
+import { getFinalKeyframe } from "./utils/get-final-keyframe.mjs";
+import { setCSSVar, setStyle } from "./utils/style.mjs";
+import { supportsPartialKeyframes } from "./utils/supports-partial-keyframes.mjs";
+import { supportsWaapi } from "./utils/supports-waapi.mjs";
+const state = /* @__PURE__ */ new WeakMap();
+function hydrateKeyframes(valueName, keyframes, read) {
+  for (let i = 0; i < keyframes.length; i++) {
+    if (keyframes[i] === null) {
+      keyframes[i] = i === 0 ? read() : keyframes[i - 1];
+    }
+    if (typeof keyframes[i] === "number" && browserNumberValueTypes[valueName]) {
+      keyframes[i] = browserNumberValueTypes[valueName].transform(keyframes[i]);
+    }
+  }
+  if (!supportsPartialKeyframes() && keyframes.length < 2) {
+    keyframes.unshift(read());
+  }
+}
+const defaultEasing = "easeOut";
+function getElementAnimationState(element) {
+  const animationState = state.get(element) || /* @__PURE__ */ new Map();
+  state.set(element, animationState);
+  return state.get(element);
+}
+class NativeAnimation extends NativeAnimationControls {
+  constructor(element, valueName, valueKeyframes, options) {
+    const isCSSVar = valueName.startsWith("--");
+    invariant(typeof options.type !== "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "framer-motion"?`);
+    const existingAnimation = getElementAnimationState(element).get(valueName);
+    existingAnimation && existingAnimation.stop();
+    const readInitialKeyframe = () => {
+      return valueName.startsWith("--") ? element.style.getPropertyValue(valueName) : window.getComputedStyle(element)[valueName];
+    };
+    if (!Array.isArray(valueKeyframes)) {
+      valueKeyframes = [valueKeyframes];
+    }
+    hydrateKeyframes(valueName, valueKeyframes, readInitialKeyframe);
+    if (isGenerator(options.type)) {
+      const generatorOptions = createGeneratorEasing(options, 100, options.type);
+      options.ease = supportsLinearEasing() ? generatorOptions.ease : defaultEasing;
+      options.duration = secondsToMilliseconds(generatorOptions.duration);
+      options.type = "keyframes";
+    } else {
+      options.ease = options.ease || defaultEasing;
+    }
+    const onFinish = () => {
+      this.setValue(element, valueName, getFinalKeyframe(valueKeyframes, options));
+      this.cancel();
+      this.resolveFinishedPromise();
+    };
+    const init = () => {
+      this.setValue = isCSSVar ? setCSSVar : setStyle;
+      this.options = options;
+      this.updateFinishedPromise();
+      this.removeAnimation = () => {
+        const elementState = state.get(element);
+        elementState && elementState.delete(valueName);
+      };
+    };
+    if (!supportsWaapi()) {
+      super();
+      init();
+      onFinish();
+    } else {
+      super(startWaapiAnimation(element, valueName, valueKeyframes, options));
+      init();
+      if (options.autoplay === false) {
+        this.animation.pause();
+      }
+      this.animation.onfinish = onFinish;
+      getElementAnimationState(element).set(valueName, this);
+    }
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(resolve, reject) {
+    return this.currentFinishedPromise.then(resolve, reject);
+  }
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((resolve) => {
+      this.resolveFinishedPromise = resolve;
+    });
+  }
+  play() {
+    if (this.state === "finished") {
+      this.updateFinishedPromise();
+    }
+    super.play();
+  }
+  cancel() {
+    this.removeAnimation();
+    super.cancel();
+  }
+}
+export {
+  NativeAnimation
+};

package/dist/es/external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/waapi/animate-elements.mjs

@@ -0,0 +1,32 @@
+import { invariant } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { secondsToMilliseconds } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
+import { getValueTransition } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/utils/get-value-transition.mjs";
+import { resolveElements } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/utils/resolve-elements.mjs";
+import { NativeAnimation } from "./NativeAnimation.mjs";
+function animateElements(elementOrSelector, keyframes, options, scope) {
+  const elements = resolveElements(elementOrSelector, scope);
+  const numElements = elements.length;
+  invariant(Boolean(numElements), "No valid element provided.");
+  const animations = [];
+  for (let i = 0; i < numElements; i++) {
+    const element = elements[i];
+    const elementTransition = { ...options };
+    if (typeof elementTransition.delay === "function") {
+      elementTransition.delay = elementTransition.delay(i, numElements);
+    }
+    for (const valueName in keyframes) {
+      const valueKeyframes = keyframes[valueName];
+      const valueOptions = {
+        ...getValueTransition(elementTransition, valueName)
+      };
+      valueOptions.duration = valueOptions.duration ? secondsToMilliseconds(valueOptions.duration) : valueOptions.duration;
+      valueOptions.delay = secondsToMilliseconds(valueOptions.delay || 0);
+      valueOptions.allowFlatten = !elementTransition.type && !elementTransition.ease;
+      animations.push(new NativeAnimation(element, valueName, valueKeyframes, valueOptions));
+    }
+  }
+  return animations;
+}
+export {
+  animateElements
+};

package/dist/es/external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/waapi/animate-style.mjs

@@ -0,0 +1,14 @@
+import { GroupPlaybackControls } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/controls/Group.mjs";
+import "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { animateElements } from "./animate-elements.mjs";
+const createScopedWaapiAnimate = (scope) => {
+  function scopedAnimate(elementOrSelector, keyframes, options) {
+    return new GroupPlaybackControls(animateElements(elementOrSelector, keyframes, options, scope));
+  }
+  return scopedAnimate;
+};
+const animateMini = /* @__PURE__ */ createScopedWaapiAnimate();
+export {
+  animateMini,
+  createScopedWaapiAnimate
+};

package/dist/es/external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/waapi/index.mjs

@@ -0,0 +1,22 @@
+import "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { mapEasingToNativeEasing } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/utils/easing.mjs";
+function startWaapiAnimation(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = "loop", ease = "easeInOut", times } = {}) {
+  const keyframeOptions = { [valueName]: keyframes };
+  if (times)
+    keyframeOptions.offset = times;
+  const easing = mapEasingToNativeEasing(ease, duration);
+  if (Array.isArray(easing))
+    keyframeOptions.easing = easing;
+  const animation = element.animate(keyframeOptions, {
+    delay,
+    duration,
+    easing: !Array.isArray(easing) ? easing : "linear",
+    fill: "both",
+    iterations: repeat + 1,
+    direction: repeatType === "reverse" ? "alternate" : "normal"
+  });
+  return animation;
+}
+export {
+  startWaapiAnimation
+};

package/dist/es/external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/waapi/utils/style.mjs

@@ -0,0 +1,10 @@
+function setCSSVar(element, name, value) {
+  element.style.setProperty(name, value);
+}
+function setStyle(element, name, value) {
+  element.style[name] = value;
+}
+export {
+  setCSSVar,
+  setStyle
+};

package/dist/es/external/.pnpm/{motion-dom@12.9.0/external/motion-dom/dist/es/animation/waapi/supports/partial-keyframes.mjs → framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/waapi/utils/supports-partial-keyframes.mjs}

@@ -1,4 +1,5 @@
-import { memo } from "../../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/memo.mjs";
+import "../../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { memo } from "../../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/memo.mjs";
 const supportsPartialKeyframes = /* @__PURE__ */ memo(() => {
   try {
     document.createElement("div").animate({ opacity: [1] });

package/dist/es/external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animators/waapi/utils/supports-waapi.mjs

@@ -0,0 +1,6 @@
+import "../../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { memo } from "../../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/memo.mjs";
+const supportsWaapi = /* @__PURE__ */ memo(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+export {
+  supportsWaapi
+};

package/dist/es/external/.pnpm/{motion-dom@12.9.0/external/motion-dom → framer-motion@12.5.0/external/framer-motion}/dist/es/animation/generators/keyframes.mjs

@@ -1,9 +1,9 @@
+import { easeInOut } from "../../easing/ease.mjs";
+import { isEasingArray } from "../../easing/utils/is-easing-array.mjs";
+import { easingDefinitionToFunction } from "../../easing/utils/map.mjs";
 import { interpolate } from "../../utils/interpolate.mjs";
-import { defaultOffset } from "../keyframes/offsets/default.mjs";
-import { convertOffsetToTimes } from "../keyframes/offsets/time.mjs";
-import { easeInOut } from "../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/easing/ease.mjs";
-import { isEasingArray } from "../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/easing/utils/is-easing-array.mjs";
-import { easingDefinitionToFunction } from "../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/easing/utils/map.mjs";
+import { defaultOffset } from "../../utils/offsets/default.mjs";
+import { convertOffsetToTimes } from "../../utils/offsets/time.mjs";
 function defaultEasing(values, easing) {
   return values.map(() => easing || easeInOut).splice(0, values.length - 1);
 }

package/dist/es/external/.pnpm/{motion-dom@12.9.0/external/motion-dom → framer-motion@12.5.0/external/framer-motion}/dist/es/animation/generators/spring/find.mjs

@@ -1,7 +1,7 @@
+import { warning } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { secondsToMilliseconds, millisecondsToSeconds } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
+import { clamp } from "../../../utils/clamp.mjs";
 import { springDefaults } from "./defaults.mjs";
-import { warning } from "../../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/errors.mjs";
-import { secondsToMilliseconds, millisecondsToSeconds } from "../../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/time-conversion.mjs";
-import { clamp } from "../../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/clamp.mjs";
 const safeMin = 1e-3;
 function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
   let envelope;

package/dist/es/external/.pnpm/{motion-dom@12.9.0/external/motion-dom → framer-motion@12.5.0/external/framer-motion}/dist/es/animation/generators/spring/index.mjs

@@ -1,11 +1,11 @@
-import { generateLinearEasing } from "../../waapi/utils/linear.mjs";
-import { calcGeneratorDuration, maxGeneratorDuration } from "../utils/calc-duration.mjs";
-import { createGeneratorEasing } from "../utils/create-generator-easing.mjs";
+import "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
+import { calcGeneratorDuration, maxGeneratorDuration } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs";
+import { generateLinearEasing } from "../../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/utils/linear.mjs";
+import { clamp } from "../../../utils/clamp.mjs";
 import { calcGeneratorVelocity } from "../utils/velocity.mjs";
 import { springDefaults } from "./defaults.mjs";
 import { findSpring, calcAngularFreq } from "./find.mjs";
-import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/time-conversion.mjs";
-import { clamp } from "../../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/clamp.mjs";
 const durationKeys = ["duration", "bounce"];
 const physicsKeys = ["stiffness", "damping", "mass"];
 function isSpringType(options, keys) {
@@ -87,7 +87,7 @@ function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce
     next: (t) => {
       const current = resolveSpring(t);
       if (!isResolvedFromDuration) {
-        let currentVelocity = t === 0 ? initialVelocity : 0;
+        let currentVelocity = 0;
         if (dampingRatio < 1) {
           currentVelocity = t === 0 ? secondsToMilliseconds(initialVelocity) : calcGeneratorVelocity(resolveSpring, t, current);
         }
@@ -104,19 +104,10 @@ function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce
       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
 };

package/dist/es/external/.pnpm/{motion-dom@12.9.0/external/motion-dom → framer-motion@12.5.0/external/framer-motion}/dist/es/animation/generators/utils/velocity.mjs

@@ -1,4 +1,5 @@
-import { velocityPerSecond } from "../../../../../../../../motion-utils@12.8.3/external/motion-utils/dist/es/velocity-per-second.mjs";
+import "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { velocityPerSecond } from "../../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/velocity-per-second.mjs";
 const velocitySampleDuration = 5;
 function calcGeneratorVelocity(resolveValue, t, current) {
   const prevT = Math.max(t - velocitySampleDuration, 0);