motion-v 0.3.0 → 0.3.1-beta.1

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/animation/animators/utils/can-animate.mjs

@@ -0,0 +1,30 @@
+import { warning } from "../../../utils/errors.mjs";
+import { isGenerator } from "../../generators/utils/is-generator.mjs";
+import { isAnimatable } from "../../utils/is-animatable.mjs";
+function hasKeyframesChanged(keyframes) {
+  const current = keyframes[0];
+  if (keyframes.length === 1)
+    return true;
+  for (let i = 0; i < keyframes.length; i++) {
+    if (keyframes[i] !== current)
+      return true;
+  }
+}
+function canAnimate(keyframes, name, type, velocity) {
+  const originKeyframe = keyframes[0];
+  if (originKeyframe === null)
+    return false;
+  if (name === "display" || name === "visibility")
+    return true;
+  const targetKeyframe = keyframes[keyframes.length - 1];
+  const isOriginAnimatable = isAnimatable(originKeyframe, name);
+  const isTargetAnimatable = isAnimatable(targetKeyframe, name);
+  warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from "${originKeyframe}" to "${targetKeyframe}". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \`style\` property.`);
+  if (!isOriginAnimatable || !isTargetAnimatable) {
+    return false;
+  }
+  return hasKeyframesChanged(keyframes) || (type === "spring" || isGenerator(type)) && velocity;
+}
+export {
+  canAnimate
+};

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

@@ -0,0 +1,162 @@
+import { startWaapiAnimation } from "./index.mjs";
+import { createGeneratorEasing } from "../../../easing/utils/create-generator-easing.mjs";
+import { browserNumberValueTypes } from "../../../render/dom/value-types/number-browser.mjs";
+import { invariant } from "../../../utils/errors.mjs";
+import { noop } from "../../../utils/noop.mjs";
+import { secondsToMilliseconds, millisecondsToSeconds } from "../../../utils/time-conversion.mjs";
+import { isGenerator } from "../../generators/utils/is-generator.mjs";
+import { attachTimeline } from "./utils/attach-timeline.mjs";
+import { getFinalKeyframe } from "./utils/get-final-keyframe.mjs";
+import { setCSSVar, setStyle } from "./utils/style.mjs";
+import { supportsLinearEasing } from "./utils/supports-linear-easing.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 {
+  constructor(element, valueName, valueKeyframes, options) {
+    const isCSSVar = valueName.startsWith("--");
+    this.setValue = isCSSVar ? setCSSVar : setStyle;
+    this.options = options;
+    this.updateFinishedPromise();
+    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;
+    }
+    this.removeAnimation = () => {
+      var _a;
+      return (_a = state.get(element)) === null || _a === void 0 ? void 0 : _a.delete(valueName);
+    };
+    const onFinish = () => {
+      this.setValue(element, valueName, getFinalKeyframe(valueKeyframes, this.options));
+      this.cancel();
+      this.resolveFinishedPromise();
+    };
+    if (!supportsWaapi()) {
+      onFinish();
+    } else {
+      this.animation = startWaapiAnimation(element, valueName, valueKeyframes, options);
+      if (options.autoplay === false) {
+        this.animation.pause();
+      }
+      this.animation.onfinish = onFinish;
+      if (this.pendingTimeline) {
+        attachTimeline(this.animation, this.pendingTimeline);
+      }
+      getElementAnimationState(element).set(valueName, this);
+    }
+  }
+  get duration() {
+    return millisecondsToSeconds(this.options.duration || 300);
+  }
+  get time() {
+    var _a;
+    if (this.animation) {
+      return millisecondsToSeconds(((_a = this.animation) === null || _a === void 0 ? void 0 : _a.currentTime) || 0);
+    }
+    return 0;
+  }
+  set time(newTime) {
+    if (this.animation) {
+      this.animation.currentTime = secondsToMilliseconds(newTime);
+    }
+  }
+  get speed() {
+    return this.animation ? this.animation.playbackRate : 1;
+  }
+  set speed(newSpeed) {
+    if (this.animation) {
+      this.animation.playbackRate = newSpeed;
+    }
+  }
+  get state() {
+    return this.animation ? this.animation.playState : "finished";
+  }
+  get startTime() {
+    return this.animation ? this.animation.startTime : null;
+  }
+  play() {
+    if (this.state === "finished") {
+      this.updateFinishedPromise();
+    }
+    this.animation && this.animation.play();
+  }
+  pause() {
+    this.animation && this.animation.pause();
+  }
+  stop() {
+    if (!this.animation || this.state === "idle" || this.state === "finished") {
+      return;
+    }
+    if (this.animation.commitStyles) {
+      this.animation.commitStyles();
+    }
+    this.cancel();
+  }
+  complete() {
+    this.animation && this.animation.finish();
+  }
+  cancel() {
+    this.removeAnimation();
+    try {
+      this.animation && this.animation.cancel();
+    } catch (e) {
+    }
+  }
+  /**
+   * 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;
+    });
+  }
+  attachTimeline(timeline) {
+    if (!this.animation) {
+      this.pendingTimeline = timeline;
+    } else {
+      attachTimeline(this.animation, timeline);
+    }
+    return noop;
+  }
+}
+export {
+  NativeAnimation
+};

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

@@ -0,0 +1,31 @@
+import { resolveElements } from "../../../render/dom/utils/resolve-element.mjs";
+import { invariant } from "../../../utils/errors.mjs";
+import { secondsToMilliseconds } from "../../../utils/time-conversion.mjs";
+import { getValueTransition } from "../../utils/get-value-transition.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(options, valueName)
+      };
+      valueOptions.duration = valueOptions.duration ? secondsToMilliseconds(valueOptions.duration) : valueOptions.duration;
+      valueOptions.delay = secondsToMilliseconds(valueOptions.delay || 0);
+      animations.push(new NativeAnimation(element, valueName, valueKeyframes, valueOptions));
+    }
+  }
+  return animations;
+}
+export {
+  animateElements
+};

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

@@ -0,0 +1,13 @@
+import { GroupPlaybackControls } from "../../GroupPlaybackControls.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@11.11.11/external/framer-motion/dist/es/animation/animators/waapi/easing.mjs

@@ -0,0 +1,37 @@
+import { isBezierDefinition } from "../../../easing/utils/is-bezier-definition.mjs";
+import { generateLinearEasing } from "./utils/linear.mjs";
+import { supportsLinearEasing } from "./utils/supports-linear-easing.mjs";
+function isWaapiSupportedEasing(easing) {
+  return Boolean(typeof easing === "function" && supportsLinearEasing() || !easing || typeof easing === "string" && (easing in supportedWaapiEasing || supportsLinearEasing()) || isBezierDefinition(easing) || Array.isArray(easing) && easing.every(isWaapiSupportedEasing));
+}
+const cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
+const supportedWaapiEasing = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ cubicBezierAsString([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ cubicBezierAsString([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ cubicBezierAsString([0.33, 1.53, 0.69, 0.99])
+};
+function mapEasingToNativeEasing(easing, duration) {
+  if (!easing) {
+    return void 0;
+  } else if (typeof easing === "function" && supportsLinearEasing()) {
+    return generateLinearEasing(easing, duration);
+  } else if (isBezierDefinition(easing)) {
+    return cubicBezierAsString(easing);
+  } else if (Array.isArray(easing)) {
+    return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) || supportedWaapiEasing.easeOut);
+  } else {
+    return supportedWaapiEasing[easing];
+  }
+}
+export {
+  cubicBezierAsString,
+  isWaapiSupportedEasing,
+  mapEasingToNativeEasing,
+  supportedWaapiEasing
+};

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

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

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/animation/animators/waapi/utils/attach-timeline.mjs

@@ -0,0 +1,7 @@
+function attachTimeline(animation, timeline) {
+  animation.timeline = timeline;
+  animation.onfinish = null;
+}
+export {
+  attachTimeline
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs

@@ -0,0 +1,9 @@
+const isNotNull = (value) => value !== null;
+function getFinalKeyframe(keyframes, { repeat, repeatType = "loop" }, finalKeyframe) {
+  const resolvedKeyframes = keyframes.filter(isNotNull);
+  const index = repeat && repeatType !== "loop" && repeat % 2 === 1 ? 0 : resolvedKeyframes.length - 1;
+  return !index || finalKeyframe === void 0 ? resolvedKeyframes[index] : finalKeyframe;
+}
+export {
+  getFinalKeyframe
+};

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

@@ -0,0 +1,13 @@
+import { progress } from "../../../../utils/progress.mjs";
+const resolution = 10;
+const generateLinearEasing = (easing, duration) => {
+  let points = "";
+  const numPoints = Math.max(Math.round(duration / resolution), 2);
+  for (let i = 0; i < numPoints; i++) {
+    points += easing(progress(0, numPoints - 1, i)) + ", ";
+  }
+  return `linear(${points.substring(0, points.length - 2)})`;
+};
+export {
+  generateLinearEasing
+};

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

@@ -0,0 +1,12 @@
+import { memo } from "../../../../utils/memo.mjs";
+import { supportsFlags } from "./supports-flags.mjs";
+function memoSupports(callback, supportsFlag) {
+  const memoized = memo(callback);
+  return () => {
+    var _a;
+    return (_a = supportsFlags[supportsFlag]) !== null && _a !== void 0 ? _a : memoized();
+  };
+}
+export {
+  memoSupports
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/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/framer-motion@11.11.11/external/framer-motion/dist/es/animation/animators/waapi/utils/supports-flags.mjs

@@ -0,0 +1,6 @@
+const supportsFlags = {
+  linearEasing: void 0
+};
+export {
+  supportsFlags
+};

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

@@ -0,0 +1,12 @@
+import { memoSupports } from "./memo-supports.mjs";
+const supportsLinearEasing = /* @__PURE__ */ memoSupports(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch (e) {
+    return false;
+  }
+  return true;
+}, "linearEasing");
+export {
+  supportsLinearEasing
+};

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

@@ -0,0 +1,12 @@
+import { memo } from "../../../../utils/memo.mjs";
+const supportsPartialKeyframes = /* @__PURE__ */ memo(() => {
+  try {
+    document.createElement("div").animate({ opacity: [1] });
+  } catch (e) {
+    return false;
+  }
+  return true;
+});
+export {
+  supportsPartialKeyframes
+};

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

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

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/animation/generators/inertia.mjs

@@ -0,0 +1,67 @@
+import { spring } from "./spring/index.mjs";
+import { calcGeneratorVelocity } from "./utils/velocity.mjs";
+function inertia({ keyframes, velocity = 0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed }) {
+  const origin = keyframes[0];
+  const state = {
+    done: false,
+    value: origin
+  };
+  const isOutOfBounds = (v) => min !== void 0 && v < min || max !== void 0 && v > max;
+  const nearestBoundary = (v) => {
+    if (min === void 0)
+      return max;
+    if (max === void 0)
+      return min;
+    return Math.abs(min - v) < Math.abs(max - v) ? min : max;
+  };
+  let amplitude = power * velocity;
+  const ideal = origin + amplitude;
+  const target = modifyTarget === void 0 ? ideal : modifyTarget(ideal);
+  if (target !== ideal)
+    amplitude = target - origin;
+  const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);
+  const calcLatest = (t) => target + calcDelta(t);
+  const applyFriction = (t) => {
+    const delta = calcDelta(t);
+    const latest = calcLatest(t);
+    state.done = Math.abs(delta) <= restDelta;
+    state.value = state.done ? target : latest;
+  };
+  let timeReachedBoundary;
+  let spring$1;
+  const checkCatchBoundary = (t) => {
+    if (!isOutOfBounds(state.value))
+      return;
+    timeReachedBoundary = t;
+    spring$1 = spring({
+      keyframes: [state.value, nearestBoundary(state.value)],
+      velocity: calcGeneratorVelocity(calcLatest, t, state.value),
+      // TODO: This should be passing * 1000
+      damping: bounceDamping,
+      stiffness: bounceStiffness,
+      restDelta,
+      restSpeed
+    });
+  };
+  checkCatchBoundary(0);
+  return {
+    calculatedDuration: null,
+    next: (t) => {
+      let hasUpdatedFrame = false;
+      if (!spring$1 && timeReachedBoundary === void 0) {
+        hasUpdatedFrame = true;
+        applyFriction(t);
+        checkCatchBoundary(t);
+      }
+      if (timeReachedBoundary !== void 0 && t >= timeReachedBoundary) {
+        return spring$1.next(t - timeReachedBoundary);
+      } else {
+        !hasUpdatedFrame && applyFriction(t);
+        return state;
+      }
+    }
+  };
+}
+export {
+  inertia
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/animation/generators/keyframes.mjs

@@ -0,0 +1,37 @@
+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 "../../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);
+}
+function keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut" }) {
+  const easingFunctions = isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);
+  const state = {
+    done: false,
+    value: keyframeValues[0]
+  };
+  const absoluteTimes = convertOffsetToTimes(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    times && times.length === keyframeValues.length ? times : defaultOffset(keyframeValues),
+    duration
+  );
+  const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {
+    ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions)
+  });
+  return {
+    calculatedDuration: duration,
+    next: (t) => {
+      state.value = mapTimeToKeyframe(t);
+      state.done = t >= duration;
+      return state;
+    }
+  };
+}
+export {
+  defaultEasing,
+  keyframes
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/animation/generators/spring/find.mjs

@@ -0,0 +1,83 @@
+import { warning } from "../../../utils/errors.mjs";
+import { clamp } from "../../../utils/clamp.mjs";
+import { secondsToMilliseconds, millisecondsToSeconds } from "../../../utils/time-conversion.mjs";
+const safeMin = 1e-3;
+const minDuration = 0.01;
+const maxDuration = 10;
+const minDamping = 0.05;
+const maxDamping = 1;
+function findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1 }) {
+  let envelope;
+  let derivative;
+  warning(duration <= secondsToMilliseconds(maxDuration), "Spring duration must be 10 seconds or less");
+  let dampingRatio = 1 - bounce;
+  dampingRatio = clamp(minDamping, maxDamping, dampingRatio);
+  duration = clamp(minDuration, 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: 100,
+      damping: 10,
+      duration
+    };
+  } else {
+    const stiffness = Math.pow(undampedFreq, 2) * mass;
+    return {
+      stiffness,
+      damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
+      duration
+    };
+  }
+}
+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;
+}
+function calcAngularFreq(undampedFreq, dampingRatio) {
+  return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
+}
+export {
+  calcAngularFreq,
+  findSpring,
+  maxDamping,
+  maxDuration,
+  minDamping,
+  minDuration
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/animation/generators/spring/index.mjs

@@ -0,0 +1,83 @@
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../utils/time-conversion.mjs";
+import { calcGeneratorVelocity } from "../utils/velocity.mjs";
+import { findSpring, calcAngularFreq } from "./find.mjs";
+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: 0,
+    stiffness: 100,
+    damping: 10,
+    mass: 1,
+    isResolvedFromDuration: false,
+    ...options
+  };
+  if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {
+    const derived = findSpring(options);
+    springOptions = {
+      ...springOptions,
+      ...derived,
+      mass: 1
+    };
+    springOptions.isResolvedFromDuration = true;
+  }
+  return springOptions;
+}
+function spring({ keyframes, restDelta, restSpeed, ...options }) {
+  const origin = keyframes[0];
+  const target = keyframes[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 ? 0.01 : 2);
+  restDelta || (restDelta = isGranularScale ? 5e-3 : 0.5);
+  let resolveSpring;
+  if (dampingRatio < 1) {
+    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
+    resolveSpring = (t) => {
+      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));
+    };
+  } else if (dampingRatio === 1) {
+    resolveSpring = (t) => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);
+  } 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;
+    };
+  }
+  return {
+    calculatedDuration: isResolvedFromDuration ? duration || null : null,
+    next: (t) => {
+      const current = resolveSpring(t);
+      if (!isResolvedFromDuration) {
+        let currentVelocity = 0;
+        if (dampingRatio < 1) {
+          currentVelocity = t === 0 ? secondsToMilliseconds(initialVelocity) : calcGeneratorVelocity(resolveSpring, t, current);
+        }
+        const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
+        const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
+        state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;
+      } else {
+        state.done = t >= duration;
+      }
+      state.value = state.done ? target : current;
+      return state;
+    }
+  };
+}
+export {
+  spring
+};