@t-headless-ui/react 1.0.0

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/delay.mjs

@@ -0,0 +1,12 @@
+import { time as s } from "../../../../motion-dom/dist/es/frameloop/sync-time.mjs";
+import { frame as m, cancelFrame as o } from "../../../../motion-dom/dist/es/frameloop/frame.mjs";
+function i(c, r) {
+  const n = s.now(), e = ({ timestamp: a }) => {
+    const t = a - n;
+    t >= r && (o(e), c(t - r));
+  };
+  return m.setup(e, !0), () => o(e);
+}
+export {
+  i as delay
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/distance.mjs

@@ -0,0 +1,9 @@
+const s = (t, n) => Math.abs(t - n);
+function e(t, n) {
+  const a = s(t.x, n.x), c = s(t.y, n.y);
+  return Math.sqrt(a ** 2 + c ** 2);
+}
+export {
+  s as distance,
+  e as distance2D
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/get-context-window.mjs

@@ -0,0 +1,4 @@
+const t = ({ current: e }) => e ? e.ownerDocument.defaultView : null;
+export {
+  t as getContextWindow
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/is-browser.mjs

@@ -0,0 +1,4 @@
+const e = typeof window < "u";
+export {
+  e as isBrowser
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/is-ref-object.mjs

@@ -0,0 +1,6 @@
+function e(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+export {
+  e as isRefObject
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/reduced-motion/index.mjs

@@ -0,0 +1,13 @@
+import { isBrowser as o } from "../is-browser.mjs";
+import { hasReducedMotionListener as i, prefersReducedMotion as t } from "./state.mjs";
+function c() {
+  if (i.current = !0, !!o)
+    if (window.matchMedia) {
+      const e = window.matchMedia("(prefers-reduced-motion)"), r = () => t.current = e.matches;
+      e.addListener(r), r();
+    } else
+      t.current = !1;
+}
+export {
+  c as initPrefersReducedMotion
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/reduced-motion/state.mjs

@@ -0,0 +1,5 @@
+const e = { current: null }, n = { current: !1 };
+export {
+  n as hasReducedMotionListener,
+  e as prefersReducedMotion
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/shallow-compare.mjs

@@ -0,0 +1,14 @@
+function f(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  const n = e.length;
+  if (n !== t.length)
+    return !1;
+  for (let r = 0; r < n; r++)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+export {
+  f as shallowCompare
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/use-constant.mjs

@@ -0,0 +1,8 @@
+import { useRef as t } from "react";
+function u(n) {
+  const r = t(null);
+  return r.current === null && (r.current = n()), r.current;
+}
+export {
+  u as useConstant
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/utils/use-isomorphic-effect.mjs

@@ -0,0 +1,6 @@
+import { useLayoutEffect as o, useEffect as t } from "react";
+import { isBrowser as e } from "./is-browser.mjs";
+const s = e ? o : t;
+export {
+  s as useIsomorphicLayoutEffect
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/value/use-will-change/add-will-change.mjs

@@ -0,0 +1,14 @@
+import { isWillChangeMotionValue as o } from "./is.mjs";
+import { MotionGlobalConfig as i } from "../../../../../motion-utils/dist/es/global-config.mjs";
+function C(a, n) {
+  const l = a.getValue("willChange");
+  if (o(l))
+    return l.add(n);
+  if (!l && i.WillChange) {
+    const e = new i.WillChange("auto");
+    a.addValue("willChange", e), e.add(n);
+  }
+}
+export {
+  C as addValueToWillChange
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/value/use-will-change/is.mjs

@@ -0,0 +1,7 @@
+import { isMotionValue as i } from "../utils/is-motion-value.mjs";
+function t(o) {
+  return !!(i(o) && o.add);
+}
+export {
+  t as isWillChangeMotionValue
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/value/utils/is-motion-value.mjs

@@ -0,0 +1,4 @@
+const t = (o) => !!(o && o.getVelocity);
+export {
+  t as isMotionValue
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/value/utils/resolve-motion-value.mjs

@@ -0,0 +1,7 @@
+import { isMotionValue as t } from "./is-motion-value.mjs";
+function e(o) {
+  return t(o) ? o.get() : o;
+}
+export {
+  e as resolveMotionValue
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/dist/es/animation/AsyncMotionValueAnimation.mjs

@@ -0,0 +1,97 @@
+import { time as v } from "../frameloop/sync-time.mjs";
+import { JSAnimation as g } from "./JSAnimation.mjs";
+import { getFinalKeyframe as y } from "./keyframes/get-final.mjs";
+import { KeyframeResolver as T, flushKeyframeResolvers as R } from "./keyframes/KeyframesResolver.mjs";
+import { NativeAnimationExtended as _ } from "./NativeAnimationExtended.mjs";
+import { canAnimate as w } from "./utils/can-animate.mjs";
+import { WithPromise as K } from "./utils/WithPromise.mjs";
+import { supportsBrowserAnimation as E } from "./waapi/supports/waapi.mjs";
+import { MotionGlobalConfig as x } from "../../../../motion-utils/dist/es/global-config.mjs";
+import { noop as M } from "../../../../motion-utils/dist/es/noop.mjs";
+const D = 40;
+class H extends K {
+  constructor({ autoplay: i = !0, delay: s = 0, type: e = "keyframes", repeat: l = 0, repeatDelay: d = 0, repeatType: f = "loop", keyframes: p, name: a, motionValue: r, element: t, ...c }) {
+    var u;
+    super(), this.stop = () => {
+      var m, h;
+      this._animation ? (this._animation.stop(), (m = this.stopTimeline) == null || m.call(this)) : (h = this.keyframeResolver) == null || h.cancel();
+    }, this.createdAt = v.now();
+    const n = {
+      autoplay: i,
+      delay: s,
+      type: e,
+      repeat: l,
+      repeatDelay: d,
+      repeatType: f,
+      name: a,
+      motionValue: r,
+      element: t,
+      ...c
+    }, o = (t == null ? void 0 : t.KeyframeResolver) || T;
+    this.keyframeResolver = new o(p, (m, h, A) => this.onKeyframesResolved(m, h, n, !A), a, r, t), (u = this.keyframeResolver) == null || u.scheduleResolve();
+  }
+  onKeyframesResolved(i, s, e, l) {
+    this.keyframeResolver = void 0;
+    const { name: d, type: f, velocity: p, delay: a, isHandoff: r, onUpdate: t } = e;
+    this.resolvedAt = v.now(), w(i, d, f, p) || ((x.instantAnimations || !a) && (t == null || t(y(i, e, s))), i[0] = i[i.length - 1], e.duration = 0, e.repeat = 0);
+    const n = {
+      startTime: l ? this.resolvedAt ? this.resolvedAt - this.createdAt > D ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: s,
+      ...e,
+      keyframes: i
+    }, o = !r && E(n) ? new _({
+      ...n,
+      element: n.motionValue.owner.current
+    }) : new g(n);
+    o.finished.then(() => this.notifyFinished()).catch(M), this.pendingTimeline && (this.stopTimeline = o.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = o;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(i, s) {
+    return this.finished.finally(i).then(() => {
+    });
+  }
+  get animation() {
+    return this._animation || R(), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(i) {
+    this.animation.time = i;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(i) {
+    this.animation.speed = i;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(i) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(i) : this.pendingTimeline = i, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    this.animation.cancel();
+  }
+}
+export {
+  H as AsyncMotionValueAnimation
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/dist/es/animation/JSAnimation.mjs

@@ -0,0 +1,129 @@
+import { time as p } from "../frameloop/sync-time.mjs";
+import { mix as G } from "../utils/mix/index.mjs";
+import { frameloopDriver as I } from "./drivers/driver-frameloop.mjs";
+import { inertia as K } from "./generators/inertia.mjs";
+import { keyframes as u } from "./generators/keyframes.mjs";
+import { calcGeneratorDuration as O } from "./generators/utils/calc-duration.mjs";
+import { getFinalKeyframe as C } from "./keyframes/get-final.mjs";
+import { replaceTransitionType as E } from "./utils/replace-transition-type.mjs";
+import { WithPromise as N } from "./utils/WithPromise.mjs";
+import { invariant as V } from "../../../../motion-utils/dist/es/errors.mjs";
+import { pipe as W } from "../../../../motion-utils/dist/es/pipe.mjs";
+import { millisecondsToSeconds as y, secondsToMilliseconds as $ } from "../../../../motion-utils/dist/es/time-conversion.mjs";
+import { clamp as B } from "../../../../motion-utils/dist/es/clamp.mjs";
+const J = (v) => v / 100;
+class et extends N {
+  constructor(t) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
+      const { motionValue: i } = this.options;
+      if (i && i.updatedAt !== p.now() && this.tick(p.now()), this.isStopped = !0, this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop: r } = this.options;
+      r && r();
+    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: t } = this;
+    E(t);
+    const { type: i = u, repeat: r = 0, repeatDelay: e = 0, repeatType: o, velocity: c = 0 } = t;
+    let { keyframes: s } = t;
+    const h = i || u;
+    process.env.NODE_ENV !== "production" && h !== u && V(s.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${s}`), h !== u && typeof s[0] != "number" && (this.mixKeyframes = W(J, G(s[0], s[1])), s = [0, 100]);
+    const n = h({ ...t, keyframes: s });
+    o === "mirror" && (this.mirroredGenerator = h({
+      ...t,
+      keyframes: [...s].reverse(),
+      velocity: -c
+    })), n.calculatedDuration === null && (n.calculatedDuration = O(n));
+    const { calculatedDuration: m } = n;
+    this.calculatedDuration = m, this.resolvedDuration = m + e, this.totalDuration = this.resolvedDuration * (r + 1) - e, this.generator = n;
+  }
+  updateTime(t) {
+    const i = Math.round(t - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = i;
+  }
+  tick(t, i = !1) {
+    const { generator: r, totalDuration: e, mixKeyframes: o, mirroredGenerator: c, resolvedDuration: s, calculatedDuration: h } = this;
+    if (this.startTime === null)
+      return r.next(0);
+    const { delay: n = 0, keyframes: m, repeat: k, repeatType: D, repeatDelay: g, type: F, onUpdate: S, finalKeyframe: P } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - e / this.speed, this.startTime)), i ? this.currentTime = t : this.updateTime(t);
+    const f = this.currentTime - n * (this.playbackSpeed >= 0 ? 1 : -1), b = this.playbackSpeed >= 0 ? f < 0 : f > e;
+    this.currentTime = Math.max(f, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = e);
+    let w = this.currentTime, x = r;
+    if (k) {
+      const T = Math.min(this.currentTime, e) / s;
+      let d = Math.floor(T), a = T % 1;
+      !a && T >= 1 && (a = 1), a === 1 && d--, d = Math.min(d, k + 1), !!(d % 2) && (D === "reverse" ? (a = 1 - a, g && (a -= g / s)) : D === "mirror" && (x = c)), w = B(0, 1, a) * s;
+    }
+    const l = b ? { done: !1, value: m[0] } : x.next(w);
+    o && (l.value = o(l.value));
+    let { done: M } = l;
+    !b && h !== null && (M = this.playbackSpeed >= 0 ? this.currentTime >= e : this.currentTime <= 0);
+    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && M);
+    return A && F !== K && (l.value = C(m, this.options, P, this.speed)), S && S(l.value), A && this.finish(), l;
+  }
+  /**
+   * 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(t, i) {
+    return this.finished.then(t, i);
+  }
+  get duration() {
+    return y(this.calculatedDuration);
+  }
+  get time() {
+    return y(this.currentTime);
+  }
+  set time(t) {
+    t = $(t), this.currentTime = t, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    this.updateTime(p.now());
+    const i = this.playbackSpeed !== t;
+    this.playbackSpeed = t, i && (this.time = y(this.currentTime));
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver: t = I, onPlay: i, startTime: r } = this.options;
+    this.driver || (this.driver = t((o) => this.tick(o))), i && i();
+    const e = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = e) : this.holdTime !== null ? this.startTime = e - this.holdTime : this.startTime || (this.startTime = r ?? e), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(p.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.teardown(), this.state = "finished";
+    const { onComplete: t } = this.options;
+    t && t();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown();
+  }
+  teardown() {
+    this.notifyFinished(), this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+  attachTimeline(t) {
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), t.observe(this);
+  }
+}
+export {
+  et as JSAnimation
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/dist/es/animation/NativeAnimation.mjs

@@ -0,0 +1,104 @@
+import { setStyle as p } from "../render/dom/style-set.mjs";
+import { supportsScrollTimeline as f } from "../utils/supports/scroll-timeline.mjs";
+import { getFinalKeyframe as u } from "./keyframes/get-final.mjs";
+import { WithPromise as d } from "./utils/WithPromise.mjs";
+import { startWaapiAnimation as c } from "./waapi/start-waapi-animation.mjs";
+import { applyGeneratorOptions as y } from "./waapi/utils/apply-generator.mjs";
+import { invariant as T } from "../../../../motion-utils/dist/es/errors.mjs";
+import { millisecondsToSeconds as r, secondsToMilliseconds as g } from "../../../../motion-utils/dist/es/time-conversion.mjs";
+import { noop as S } from "../../../../motion-utils/dist/es/noop.mjs";
+class x extends d {
+  constructor(i) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, !i)
+      return;
+    const { element: t, name: e, keyframes: a, pseudoElement: n, allowFlatten: h = !1, finalKeyframe: l, onComplete: s } = i;
+    this.isPseudoElement = !!n, this.allowFlatten = h, this.options = i, T(typeof i.type != "string", `animateMini doesn't support "type" as a string. Did you mean to import { spring } from "motion"?`);
+    const o = y(i);
+    this.animation = c(t, e, a, o, n), o.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !n) {
+        const m = u(a, this.options, l, this.speed);
+        this.updateMotionValue ? this.updateMotionValue(m) : p(t, e, m), this.animation.cancel();
+      }
+      s == null || s(), this.notifyFinished();
+    }, this.animation.oncancel = () => this.notifyFinished();
+  }
+  play() {
+    this.isStopped || (this.animation.play(), this.state === "finished" && this.updateFinished());
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    var i, t;
+    (t = (i = this.animation).finish) == null || t.call(i);
+  }
+  cancel() {
+    try {
+      this.animation.cancel();
+    } catch {
+    }
+  }
+  stop() {
+    if (this.isStopped)
+      return;
+    this.isStopped = !0;
+    const { state: i } = this;
+    i === "idle" || i === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * In this method, we commit styles back to the DOM before cancelling
+   * the animation.
+   *
+   * This is designed to be overridden by NativeAnimationExtended, which
+   * will create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to also correctly calculate velocity for any subsequent animation
+   * while deferring the commit until the next animation frame.
+   */
+  commitStyles() {
+    var i, t;
+    this.isPseudoElement || (t = (i = this.animation).commitStyles) == null || t.call(i);
+  }
+  get duration() {
+    var t, e;
+    const i = ((e = (t = this.animation.effect) == null ? void 0 : t.getComputedTiming) == null ? void 0 : e.call(t).duration) || 0;
+    return r(Number(i));
+  }
+  get time() {
+    return r(Number(this.animation.currentTime) || 0);
+  }
+  set time(i) {
+    this.finishedTime = null, this.animation.currentTime = g(i);
+  }
+  /**
+   * The playback speed of the animation.
+   * 1 = normal speed, 2 = double speed, 0.5 = half speed.
+   */
+  get speed() {
+    return this.animation.playbackRate;
+  }
+  set speed(i) {
+    i < 0 && (this.finishedTime = null), this.animation.playbackRate = i;
+  }
+  get state() {
+    return this.finishedTime !== null ? "finished" : this.animation.playState;
+  }
+  get startTime() {
+    return Number(this.animation.startTime);
+  }
+  set startTime(i) {
+    this.animation.startTime = i;
+  }
+  /**
+   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
+   */
+  attachTimeline({ timeline: i, observe: t }) {
+    var e;
+    return this.allowFlatten && ((e = this.animation.effect) == null || e.updateTiming({ easing: "linear" })), this.animation.onfinish = null, i && f() ? (this.animation.timeline = i, S) : t(this);
+  }
+}
+export {
+  x as NativeAnimation
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/dist/es/animation/NativeAnimationExtended.mjs

@@ -0,0 +1,36 @@
+import { JSAnimation as a } from "./JSAnimation.mjs";
+import { NativeAnimation as m } from "./NativeAnimation.mjs";
+import { replaceTransitionType as r } from "./utils/replace-transition-type.mjs";
+import { replaceStringEasing as l } from "./waapi/utils/unsupported-easing.mjs";
+import { secondsToMilliseconds as p } from "../../../../motion-utils/dist/es/time-conversion.mjs";
+const s = 10;
+class y extends m {
+  constructor(e) {
+    l(e), r(e), super(e), e.startTime && (this.startTime = e.startTime), this.options = e;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read commited styles back out of the DOM, we can
+   * create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to calculate velocity for any subsequent animation.
+   */
+  updateMotionValue(e) {
+    const { motionValue: t, onUpdate: f, onComplete: d, element: u, ...n } = this.options;
+    if (!t)
+      return;
+    if (e !== void 0) {
+      t.set(e);
+      return;
+    }
+    const i = new a({
+      ...n,
+      autoplay: !1
+    }), o = p(this.finishedTime ?? this.time);
+    t.setWithVelocity(i.sample(o - s).value, i.sample(o).value, s), i.stop();
+  }
+}
+export {
+  y as NativeAnimationExtended
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/dist/es/animation/drivers/driver-frameloop.mjs

@@ -0,0 +1,17 @@
+import { time as o } from "../../frameloop/sync-time.mjs";
+import { frameData as t, cancelFrame as a, frame as s } from "../../frameloop/frame.mjs";
+const n = (e) => {
+  const r = ({ timestamp: m }) => e(m);
+  return {
+    start: () => s.update(r, !0),
+    stop: () => a(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/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/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/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/dist/es/animation/generators/keyframes.mjs

@@ -0,0 +1,30 @@
+import { interpolate as c } from "../../utils/interpolate.mjs";
+import { defaultOffset as p } from "../keyframes/offsets/default.mjs";
+import { convertOffsetToTimes as u } from "../keyframes/offsets/time.mjs";
+import { easeInOut as l } from "../../../../../motion-utils/dist/es/easing/ease.mjs";
+import { isEasingArray as g } from "../../../../../motion-utils/dist/es/easing/utils/is-easing-array.mjs";
+import { easingDefinitionToFunction as m } from "../../../../../motion-utils/dist/es/easing/utils/map.mjs";
+function T(n, t) {
+  return n.map(() => t || l).splice(0, n.length - 1);
+}
+function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
+  const e = g(r) ? r.map(m) : m(r), i = {
+    done: !1,
+    value: t[0]
+  }, s = u(
+    // 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 : p(t),
+    n
+  ), a = c(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/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/motion-dom/dist/es/animation/generators/spring/defaults.mjs

@@ -0,0 +1,32 @@
+const a = {
+  // 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
+};
+export {
+  a as springDefaults
+};