motion-v 0.2.5 → 0.3.0

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs

@@ -0,0 +1,148 @@
+import { KeyframeResolver as x } from "../../render/utils/KeyframesResolver.mjs";
+import { spring as G } from "../generators/spring/index.mjs";
+import { inertia as b } from "../generators/inertia.mjs";
+import { keyframes as y } from "../generators/keyframes.mjs";
+import { BaseAnimation as I } from "./BaseAnimation.mjs";
+import { pipe as O } from "../../utils/pipe.mjs";
+import { mix as _ } from "../../utils/mix/index.mjs";
+import { calcGeneratorDuration as A } from "../generators/utils/calc-duration.mjs";
+import { millisecondsToSeconds as D, secondsToMilliseconds as V } from "../../utils/time-conversion.mjs";
+import { clamp as B } from "../../utils/clamp.mjs";
+import { invariant as C } from "../../utils/errors.mjs";
+import { frameloopDriver as E } from "./drivers/driver-frameloop.mjs";
+import { getFinalKeyframe as N } from "./waapi/utils/get-final-keyframe.mjs";
+import { isGenerator as U } from "../generators/utils/is-generator.mjs";
+const W = {
+  decay: b,
+  inertia: b,
+  tween: y,
+  keyframes: y,
+  spring: G
+}, j = (p) => p / 100;
+class q extends I {
+  constructor(t) {
+    super(t), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
+      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop: n } = this.options;
+      n && n();
+    };
+    const { name: i, motionValue: r, element: e, keyframes: o } = this.options, u = (e == null ? void 0 : e.KeyframeResolver) || x, a = (n, l) => this.onKeyframesResolved(n, l);
+    this.resolver = new u(o, a, i, r, e), this.resolver.scheduleResolve();
+  }
+  initPlayback(t) {
+    const { type: i = "keyframes", repeat: r = 0, repeatDelay: e = 0, repeatType: o, velocity: u = 0 } = this.options, a = U(i) ? i : W[i] || y;
+    let n, l;
+    a !== y && typeof t[0] != "number" && (process.env.NODE_ENV !== "production" && C(t.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${t}`), n = O(j, _(t[0], t[1])), t = [0, 100]);
+    const s = a({ ...this.options, keyframes: t });
+    o === "mirror" && (l = a({
+      ...this.options,
+      keyframes: [...t].reverse(),
+      velocity: -u
+    })), s.calculatedDuration === null && (s.calculatedDuration = A(s));
+    const { calculatedDuration: d } = s, f = d + e, T = f * (r + 1) - e;
+    return {
+      generator: s,
+      mirroredGenerator: l,
+      mapPercentToKeyframes: n,
+      calculatedDuration: d,
+      resolvedDuration: f,
+      totalDuration: T
+    };
+  }
+  onPostResolved() {
+    const { autoplay: t = !0 } = this.options;
+    this.play(), this.pendingPlayState === "paused" || !t ? this.pause() : this.state = this.pendingPlayState;
+  }
+  tick(t, i = !1) {
+    const { resolved: r } = this;
+    if (!r) {
+      const { keyframes: c } = this.options;
+      return { done: !0, value: c[c.length - 1] };
+    }
+    const { finalKeyframe: e, generator: o, mirroredGenerator: u, mapPercentToKeyframes: a, keyframes: n, calculatedDuration: l, totalDuration: s, resolvedDuration: d } = r;
+    if (this.startTime === null)
+      return o.next(0);
+    const { delay: f, repeat: T, repeatType: P, repeatDelay: S, onUpdate: k } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - s / this.speed, this.startTime)), i ? this.currentTime = t : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(t - this.startTime) * this.speed;
+    const g = this.currentTime - f * (this.speed >= 0 ? 1 : -1), M = this.speed >= 0 ? g < 0 : g > s;
+    this.currentTime = Math.max(g, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
+    let K = this.currentTime, w = o;
+    if (T) {
+      const c = Math.min(this.currentTime, s) / d;
+      let v = Math.floor(c), h = c % 1;
+      !h && c >= 1 && (h = 1), h === 1 && v--, v = Math.min(v, T + 1), !!(v % 2) && (P === "reverse" ? (h = 1 - h, S && (h -= S / d)) : P === "mirror" && (w = u)), K = B(0, 1, h) * d;
+    }
+    const m = M ? { done: !1, value: n[0] } : w.next(K);
+    a && (m.value = a(m.value));
+    let { done: F } = m;
+    !M && l !== null && (F = this.speed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
+    const R = this.holdTime === null && (this.state === "finished" || this.state === "running" && F);
+    return R && e !== void 0 && (m.value = N(n, this.options, e)), k && k(m.value), R && this.finish(), m;
+  }
+  get duration() {
+    const { resolved: t } = this;
+    return t ? D(t.calculatedDuration) : 0;
+  }
+  get time() {
+    return D(this.currentTime);
+  }
+  set time(t) {
+    t = V(t), this.currentTime = t, this.holdTime !== null || this.speed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.speed);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const i = this.playbackSpeed !== t;
+    this.playbackSpeed = t, i && (this.time = D(this.currentTime));
+  }
+  play() {
+    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
+      this.pendingPlayState = "running";
+      return;
+    }
+    if (this.isStopped)
+      return;
+    const { driver: t = E, onPlay: i, startTime: r } = this.options;
+    this.driver || (this.driver = t((o) => this.tick(o))), i && i();
+    const e = this.driver.now();
+    this.holdTime !== null ? this.startTime = e - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = e) : this.startTime = r ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    var t;
+    if (!this._resolved) {
+      this.pendingPlayState = "paused";
+      return;
+    }
+    this.state = "paused", this.holdTime = (t = this.currentTime) !== null && t !== void 0 ? t : 0;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.teardown(), this.state = "finished";
+    const { onComplete: t } = this.options;
+    t && t();
+  }
+  cancel() {
+    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() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+}
+function ot(p) {
+  return new q(p);
+}
+export {
+  q as MainThreadAnimation,
+  ot as animateValue
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs

@@ -0,0 +1,17 @@
+import { time as o } from "../../../frameloop/sync-time.mjs";
+import { frame as a, cancelFrame as s, frameData as t } from "../../../frameloop/frame.mjs";
+const n = (e) => {
+  const r = ({ timestamp: m }) => e(m);
+  return {
+    start: () => a.update(r, !0),
+    stop: () => s(r),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => t.isProcessing ? t.timestamp : o.now()
+  };
+};
+export {
+  n as frameloopDriver
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs

@@ -0,0 +1,12 @@
+const e = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
+  // or until we implement support for linear() easing.
+  // "background-color"
+]);
+export {
+  e as acceleratedValues
+};

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

@@ -0,0 +1,23 @@
+import { warning as s } from "../../../utils/errors.mjs";
+import { isGenerator as f } from "../../generators/utils/is-generator.mjs";
+import { isAnimatable as l } from "../../utils/is-animatable.mjs";
+function g(t) {
+  const i = t[0];
+  if (t.length === 1)
+    return !0;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] !== i)
+      return !0;
+}
+function h(t, i, n, u) {
+  const r = t[0];
+  if (r === null)
+    return !1;
+  if (i === "display" || i === "visibility")
+    return !0;
+  const a = t[t.length - 1], e = l(r, i), o = l(a, i);
+  return s(e === o, `You are trying to animate ${i} from "${r}" to "${a}". ${r} is not an animatable value - to enable this animation set ${r} to a value animatable to ${a} via the \`style\` property.`), !e || !o ? !1 : g(t) || (n === "spring" || f(n)) && u;
+}
+export {
+  h as canAnimate
+};

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

@@ -0,0 +1,106 @@
+import { startWaapiAnimation as y } from "./index.mjs";
+import { createGeneratorEasing as S } from "../../../easing/utils/create-generator-easing.mjs";
+import { browserNumberValueTypes as m } from "../../../render/dom/value-types/number-browser.mjs";
+import { invariant as T } from "../../../utils/errors.mjs";
+import { noop as P } from "../../../utils/noop.mjs";
+import { secondsToMilliseconds as p, millisecondsToSeconds as c } from "../../../utils/time-conversion.mjs";
+import { isGenerator as F } from "../../generators/utils/is-generator.mjs";
+import { attachTimeline as d } from "./utils/attach-timeline.mjs";
+import { getFinalKeyframe as A } from "./utils/get-final-keyframe.mjs";
+import { setCSSVar as w, setStyle as V } from "./utils/style.mjs";
+import { supportsLinearEasing as b } from "./utils/supports-linear-easing.mjs";
+import { supportsPartialKeyframes as W } from "./utils/supports-partial-keyframes.mjs";
+import { supportsWaapi as E } from "./utils/supports-waapi.mjs";
+const o = /* @__PURE__ */ new WeakMap();
+function M(a, i, n) {
+  for (let t = 0; t < i.length; t++)
+    i[t] === null && (i[t] = t === 0 ? n() : i[t - 1]), typeof i[t] == "number" && m[a] && (i[t] = m[a].transform(i[t]));
+  !W() && i.length < 2 && i.unshift(n());
+}
+const f = "easeOut";
+function u(a) {
+  const i = o.get(a) || /* @__PURE__ */ new Map();
+  return o.set(a, i), o.get(a);
+}
+class H {
+  constructor(i, n, t, s) {
+    const l = n.startsWith("--");
+    this.setValue = l ? w : V, this.options = s, this.updateFinishedPromise(), T(typeof s.type != "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "framer-motion"?`);
+    const r = u(i).get(n);
+    r && r.stop();
+    const g = () => n.startsWith("--") ? i.style.getPropertyValue(n) : window.getComputedStyle(i)[n];
+    if (Array.isArray(t) || (t = [t]), M(n, t, g), F(s.type)) {
+      const e = S(s, 100, s.type);
+      s.ease = b() ? e.ease : f, s.duration = p(e.duration), s.type = "keyframes";
+    } else
+      s.ease = s.ease || f;
+    this.removeAnimation = () => {
+      var e;
+      return (e = o.get(i)) === null || e === void 0 ? void 0 : e.delete(n);
+    };
+    const h = () => {
+      this.setValue(i, n, A(t, this.options)), this.cancel(), this.resolveFinishedPromise();
+    };
+    E() ? (this.animation = y(i, n, t, s), s.autoplay === !1 && this.animation.pause(), this.animation.onfinish = h, this.pendingTimeline && d(this.animation, this.pendingTimeline), u(i).set(n, this)) : h();
+  }
+  get duration() {
+    return c(this.options.duration || 300);
+  }
+  get time() {
+    var i;
+    return this.animation ? c(((i = this.animation) === null || i === void 0 ? void 0 : i.currentTime) || 0) : 0;
+  }
+  set time(i) {
+    this.animation && (this.animation.currentTime = p(i));
+  }
+  get speed() {
+    return this.animation ? this.animation.playbackRate : 1;
+  }
+  set speed(i) {
+    this.animation && (this.animation.playbackRate = i);
+  }
+  get state() {
+    return this.animation ? this.animation.playState : "finished";
+  }
+  get startTime() {
+    return this.animation ? this.animation.startTime : null;
+  }
+  play() {
+    this.state === "finished" && this.updateFinishedPromise(), this.animation && this.animation.play();
+  }
+  pause() {
+    this.animation && this.animation.pause();
+  }
+  stop() {
+    !this.animation || this.state === "idle" || this.state === "finished" || (this.animation.commitStyles && this.animation.commitStyles(), this.cancel());
+  }
+  complete() {
+    this.animation && this.animation.finish();
+  }
+  cancel() {
+    this.removeAnimation();
+    try {
+      this.animation && this.animation.cancel();
+    } catch {
+    }
+  }
+  /**
+   * 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(i, n) {
+    return this.currentFinishedPromise.then(i, n);
+  }
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((i) => {
+      this.resolveFinishedPromise = i;
+    });
+  }
+  attachTimeline(i) {
+    return this.animation ? d(this.animation, i) : this.pendingTimeline = i, P;
+  }
+}
+export {
+  H as NativeAnimation
+};

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

@@ -0,0 +1,24 @@
+import { resolveElements as p } from "../../../render/dom/utils/resolve-element.mjs";
+import { invariant as v } from "../../../utils/errors.mjs";
+import { secondsToMilliseconds as s } from "../../../utils/time-conversion.mjs";
+import { getValueTransition as y } from "../../utils/get-value-transition.mjs";
+import { NativeAnimation as E } from "./NativeAnimation.mjs";
+function x(d, a, r, u) {
+  const l = p(d, u), o = l.length;
+  v(!!o, "No valid element provided.");
+  const m = [];
+  for (let n = 0; n < o; n++) {
+    const c = l[n], t = { ...r };
+    typeof t.delay == "function" && (t.delay = t.delay(n, o));
+    for (const i in a) {
+      const f = a[i], e = {
+        ...y(r, i)
+      };
+      e.duration = e.duration ? s(e.duration) : e.duration, e.delay = s(e.delay || 0), m.push(new E(c, i, f, e));
+    }
+  }
+  return m;
+}
+export {
+  x as animateElements
+};

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

@@ -0,0 +1,12 @@
+import { GroupPlaybackControls as a } from "../../GroupPlaybackControls.mjs";
+import { animateElements as i } from "./animate-elements.mjs";
+const m = (t) => {
+  function e(n, o, r) {
+    return new a(i(n, o, r, t));
+  }
+  return e;
+}, s = /* @__PURE__ */ m();
+export {
+  s as animateMini,
+  m as createScopedWaapiAnimate
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/waapi/easing.mjs

@@ -0,0 +1,27 @@
+import { isBezierDefinition as u } from "../../../easing/utils/is-bezier-definition.mjs";
+import { generateLinearEasing as p } from "./utils/linear.mjs";
+import { supportsLinearEasing as n } from "./utils/supports-linear-easing.mjs";
+function s(e) {
+  return !!(typeof e == "function" && n() || !e || typeof e == "string" && (e in o || n()) || u(e) || Array.isArray(e) && e.every(s));
+}
+const r = ([e, t, i, a]) => `cubic-bezier(${e}, ${t}, ${i}, ${a})`, o = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ r([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ r([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ r([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ r([0.33, 1.53, 0.69, 0.99])
+};
+function c(e, t) {
+  if (e)
+    return typeof e == "function" && n() ? p(e, t) : u(e) ? r(e) : Array.isArray(e) ? e.map((i) => c(i, t) || o.easeOut) : o[e];
+}
+export {
+  r as cubicBezierAsString,
+  s as isWaapiSupportedEasing,
+  c as mapEasingToNativeEasing,
+  o as supportedWaapiEasing
+};

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

@@ -0,0 +1,17 @@
+import { mapEasingToNativeEasing as p } from "./easing.mjs";
+function y(e, t, o, { delay: s = 0, duration: r = 300, repeat: f = 0, repeatType: l = "loop", ease: m, times: n } = {}) {
+  const i = { [t]: o };
+  n && (i.offset = n);
+  const a = p(m, r);
+  return Array.isArray(a) && (i.easing = a), e.animate(i, {
+    delay: s,
+    duration: r,
+    easing: Array.isArray(a) ? "linear" : a,
+    fill: "both",
+    iterations: f + 1,
+    direction: l === "reverse" ? "alternate" : "normal"
+  });
+}
+export {
+  y as startWaapiAnimation
+};

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

@@ -0,0 +1,6 @@
+function n(e, i) {
+  e.timeline = i, e.onfinish = null;
+}
+export {
+  n as attachTimeline
+};

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

@@ -0,0 +1,8 @@
+const i = (n) => n !== null;
+function r(n, { repeat: o, repeatType: s = "loop" }, e) {
+  const l = n.filter(i), t = o && s !== "loop" && o % 2 === 1 ? 0 : l.length - 1;
+  return !t || e === void 0 ? l[t] : e;
+}
+export {
+  r as getFinalKeyframe
+};

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

@@ -0,0 +1,11 @@
+import { progress as s } from "../../../../utils/progress.mjs";
+const i = 10, g = (o, e) => {
+  let t = "";
+  const r = Math.max(Math.round(e / i), 2);
+  for (let n = 0; n < r; n++)
+    t += o(s(0, r - 1, n)) + ", ";
+  return `linear(${t.substring(0, t.length - 2)})`;
+};
+export {
+  g as generateLinearEasing
+};

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

@@ -0,0 +1,12 @@
+import { memo as e } from "../../../../utils/memo.mjs";
+import { supportsFlags as p } from "./supports-flags.mjs";
+function i(r, m) {
+  const t = e(r);
+  return () => {
+    var o;
+    return (o = p[m]) !== null && o !== void 0 ? o : t();
+  };
+}
+export {
+  i as memoSupports
+};

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

@@ -0,0 +1,10 @@
+function n(t, e, s) {
+  t.style.setProperty(`--${e}`, s);
+}
+function o(t, e, s) {
+  t.style[e] = s;
+}
+export {
+  n as setCSSVar,
+  o as setStyle
+};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,37 @@
+import { spring as L } from "./spring/index.mjs";
+import { calcGeneratorVelocity as R } from "./utils/velocity.mjs";
+function $({ keyframes: g, velocity: B = 0, power: M = 0.8, timeConstant: b = 325, bounceDamping: k = 10, bounceStiffness: F = 500, modifyTarget: l, min: t, max: a, restDelta: f = 0.5, restSpeed: O }) {
+  const s = g[0], n = {
+    done: !1,
+    value: s
+  }, C = (e) => t !== void 0 && e < t || a !== void 0 && e > a, D = (e) => t === void 0 ? a : a === void 0 || Math.abs(t - e) < Math.abs(a - e) ? t : a;
+  let c = M * B;
+  const d = s + c, u = l === void 0 ? d : l(d);
+  u !== d && (c = u - s);
+  const p = (e) => -c * Math.exp(-e / b), h = (e) => u + p(e), y = (e) => {
+    const o = p(e), G = h(e);
+    n.done = Math.abs(o) <= f, n.value = n.done ? u : G;
+  };
+  let r, i;
+  const v = (e) => {
+    C(n.value) && (r = e, i = L({
+      keyframes: [n.value, D(n.value)],
+      velocity: R(h, e, n.value),
+      // TODO: This should be passing * 1000
+      damping: k,
+      stiffness: F,
+      restDelta: f,
+      restSpeed: O
+    }));
+  };
+  return v(0), {
+    calculatedDuration: null,
+    next: (e) => {
+      let o = !1;
+      return !i && r === void 0 && (o = !0, y(e), v(e)), r !== void 0 && e >= r ? i.next(e - r) : (!o && y(e), n);
+    }
+  };
+}
+export {
+  $ as inertia
+};

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

@@ -0,0 +1,30 @@
+import { easeInOut as c } from "../../easing/ease.mjs";
+import { isEasingArray as p } from "../../easing/utils/is-easing-array.mjs";
+import { easingDefinitionToFunction as m } from "../../easing/utils/map.mjs";
+import { interpolate as u } from "../../utils/interpolate.mjs";
+import { defaultOffset as l } from "../../utils/offsets/default.mjs";
+import { convertOffsetToTimes as g } from "../../utils/offsets/time.mjs";
+function T(n, t) {
+  return n.map(() => t || c).splice(0, n.length - 1);
+}
+function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
+  const e = p(r) ? r.map(m) : m(r), i = {
+    done: !1,
+    value: t[0]
+  }, s = g(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    o && o.length === t.length ? o : l(t),
+    n
+  ), a = u(s, t, {
+    ease: Array.isArray(e) ? e : T(t, e)
+  });
+  return {
+    calculatedDuration: n,
+    next: (f) => (i.value = a(f), i.done = f >= n, i)
+  };
+}
+export {
+  T as defaultEasing,
+  y as keyframes
+};

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

@@ -0,0 +1,55 @@
+import { warning as N } from "../../../utils/errors.mjs";
+import { clamp as h } from "../../../utils/clamp.mjs";
+import { secondsToMilliseconds as g, millisecondsToSeconds as T } from "../../../utils/time-conversion.mjs";
+const M = 1e-3, A = 0.01, D = 10, G = 0.05, I = 1;
+function E({ duration: t = 800, bounce: i = 0.25, velocity: c = 0, mass: o = 1 }) {
+  let a, p;
+  N(t <= g(D), "Spring duration must be 10 seconds or less");
+  let s = 1 - i;
+  s = h(G, I, s), t = h(A, D, T(t)), s < 1 ? (a = (n) => {
+    const r = n * s, e = r * t, l = r - c, f = w(n, s), m = Math.exp(-e);
+    return M - l / f * m;
+  }, p = (n) => {
+    const e = n * s * t, l = e * c + c, f = Math.pow(s, 2) * Math.pow(n, 2) * t, m = Math.exp(-e), S = w(Math.pow(n, 2), s);
+    return (-a(n) + M > 0 ? -1 : 1) * ((l - f) * m) / S;
+  }) : (a = (n) => {
+    const r = Math.exp(-n * t), e = (n - c) * t + 1;
+    return -M + r * e;
+  }, p = (n) => {
+    const r = Math.exp(-n * t), e = (c - n) * (t * t);
+    return r * e;
+  });
+  const b = 5 / t, x = j(a, p, b);
+  if (t = g(t), isNaN(x))
+    return {
+      stiffness: 100,
+      damping: 10,
+      duration: t
+    };
+  {
+    const n = Math.pow(x, 2) * o;
+    return {
+      stiffness: n,
+      damping: s * 2 * Math.sqrt(o * n),
+      duration: t
+    };
+  }
+}
+const R = 12;
+function j(t, i, c) {
+  let o = c;
+  for (let a = 1; a < R; a++)
+    o = o - t(o) / i(o);
+  return o;
+}
+function w(t, i) {
+  return t * Math.sqrt(1 - i * i);
+}
+export {
+  w as calcAngularFreq,
+  E as findSpring,
+  I as maxDamping,
+  D as maxDuration,
+  G as minDamping,
+  A as minDuration
+};