@t-headless-ui/react 1.1.1 → 1.1.3

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/NativeAnimation.mjs

@@ -0,0 +1,109 @@
+import { setStyle as u } from "../render/dom/style-set.mjs";
+import { supportsScrollTimeline as p } from "../utils/supports/scroll-timeline.mjs";
+import { getFinalKeyframe as f } 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 T } from "./waapi/utils/apply-generator.mjs";
+import { invariant as y } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/errors.mjs";
+import { millisecondsToSeconds as o, secondsToMilliseconds as S } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.mjs";
+import { noop as g } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/noop.mjs";
+class x extends d {
+  constructor(i) {
+    if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !i)
+      return;
+    const { element: t, name: e, keyframes: n, pseudoElement: s, allowFlatten: l = !1, finalKeyframe: h, onComplete: a } = i;
+    this.isPseudoElement = !!s, this.allowFlatten = l, this.options = i, y(typeof i.type != "string", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
+    const m = T(i);
+    this.animation = c(t, e, n, m, s), m.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !s) {
+        const r = f(n, this.options, h, this.speed);
+        this.updateMotionValue ? this.updateMotionValue(r) : u(t, e, r), this.animation.cancel();
+      }
+      a == null || a(), this.notifyFinished();
+    };
+  }
+  play() {
+    this.isStopped || (this.manualStartTime = null, 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 t, e, n;
+    const i = (t = this.options) == null ? void 0 : t.element;
+    !this.isPseudoElement && (i != null && i.isConnected) && ((n = (e = this.animation).commitStyles) == null || n.call(e));
+  }
+  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 o(Number(i));
+  }
+  get iterationDuration() {
+    const { delay: i = 0 } = this.options || {};
+    return this.duration + o(i);
+  }
+  get time() {
+    return o(Number(this.animation.currentTime) || 0);
+  }
+  set time(i) {
+    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = S(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 this.manualStartTime ?? Number(this.animation.startTime);
+  }
+  set startTime(i) {
+    this.manualStartTime = 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 && p() ? (this.animation.timeline = i, g) : t(this);
+  }
+}
+export {
+  x as NativeAnimation
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs

@@ -0,0 +1,37 @@
+import { time as r } from "../frameloop/sync-time.mjs";
+import { JSAnimation as s } from "./JSAnimation.mjs";
+import { NativeAnimation as p } from "./NativeAnimation.mjs";
+import { replaceTransitionType as l } from "./utils/replace-transition-type.mjs";
+import { replaceStringEasing as c } from "./waapi/utils/unsupported-easing.mjs";
+import { clamp as f } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.mjs";
+const m = 10;
+class g extends p {
+  constructor(t) {
+    c(t), l(t), super(t), t.startTime !== void 0 && (this.startTime = t.startTime), this.options = t;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read committed 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(t) {
+    const { motionValue: e, onUpdate: d, onComplete: h, element: T, ...n } = this.options;
+    if (!e)
+      return;
+    if (t !== void 0) {
+      e.set(t);
+      return;
+    }
+    const i = new s({
+      ...n,
+      autoplay: !1
+    }), a = Math.max(m, r.now() - this.startTime), o = f(0, m, a - m);
+    e.setWithVelocity(i.sample(Math.max(0, a - o)).value, i.sample(a).value, o), i.stop();
+  }
+}
+export {
+  g as NativeAnimationExtended
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/animate/single-value.mjs

@@ -0,0 +1,10 @@
+import { animateMotionValue as m } from "../interfaces/motion-value.mjs";
+import { motionValue as a } from "../../value/index.mjs";
+import { isMotionValue as r } from "../../value/utils/is-motion-value.mjs";
+function f(o, i, n) {
+  const t = r(o) ? o : a(o);
+  return t.start(m("", t, i, n)), t.animation;
+}
+export {
+  f as animateSingleValue
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/drivers/frame.mjs

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

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/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 { isEasingArray as l } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/utils/is-easing-array.mjs";
+import { easingDefinitionToFunction as m } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/utils/map.mjs";
+import { easeInOut as g } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/ease.mjs";
+function T(n, t) {
+  return n.map(() => t || g).splice(0, n.length - 1);
+}
+function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
+  const e = l(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-dom@12.31.2/node_modules/motion-dom/dist/es/animation/generators/spring/find.mjs

@@ -0,0 +1,52 @@
+import { springDefaults as s } from "./defaults.mjs";
+import { warning as S } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/errors.mjs";
+import { secondsToMilliseconds as h, millisecondsToSeconds as N } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.mjs";
+import { clamp as D } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.mjs";
+const x = 1e-3;
+function v({ duration: t = s.duration, bounce: p = s.bounce, velocity: i = s.velocity, mass: e = s.mass }) {
+  let a, f;
+  S(t <= h(s.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let o = 1 - p;
+  o = D(s.minDamping, s.maxDamping, o), t = D(s.minDuration, s.maxDuration, N(t)), o < 1 ? (a = (n) => {
+    const r = n * o, c = r * t, l = r - i, m = b(n, o), g = Math.exp(-c);
+    return x - l / m * g;
+  }, f = (n) => {
+    const c = n * o * t, l = c * i + i, m = Math.pow(o, 2) * Math.pow(n, 2) * t, g = Math.exp(-c), u = b(Math.pow(n, 2), o);
+    return (-a(n) + x > 0 ? -1 : 1) * ((l - m) * g) / u;
+  }) : (a = (n) => {
+    const r = Math.exp(-n * t), c = (n - i) * t + 1;
+    return -x + r * c;
+  }, f = (n) => {
+    const r = Math.exp(-n * t), c = (i - n) * (t * t);
+    return r * c;
+  });
+  const w = 5 / t, M = A(a, f, w);
+  if (t = h(t), isNaN(M))
+    return {
+      stiffness: s.stiffness,
+      damping: s.damping,
+      duration: t
+    };
+  {
+    const n = Math.pow(M, 2) * e;
+    return {
+      stiffness: n,
+      damping: o * 2 * Math.sqrt(e * n),
+      duration: t
+    };
+  }
+}
+const T = 12;
+function A(t, p, i) {
+  let e = i;
+  for (let a = 1; a < T; a++)
+    e = e - t(e) / p(e);
+  return e;
+}
+function b(t, p) {
+  return t * Math.sqrt(1 - p * p);
+}
+export {
+  b as calcAngularFreq,
+  v as findSpring
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/generators/spring/index.mjs

@@ -0,0 +1,98 @@
+import { generateLinearEasing as w } from "../../waapi/utils/linear.mjs";
+import { calcGeneratorDuration as B, maxGeneratorDuration as E } from "../utils/calc-duration.mjs";
+import { createGeneratorEasing as K } from "../utils/create-generator-easing.mjs";
+import { calcGeneratorVelocity as O } from "../utils/velocity.mjs";
+import { springDefaults as a } from "./defaults.mjs";
+import { findSpring as V, calcAngularFreq as j } from "./find.mjs";
+import { millisecondsToSeconds as T, secondsToMilliseconds as k } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.mjs";
+import { clamp as I } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.mjs";
+const L = ["duration", "bounce"], P = ["stiffness", "damping", "mass"];
+function b(t, n) {
+  return n.some((s) => t[s] !== void 0);
+}
+function z(t) {
+  let n = {
+    velocity: a.velocity,
+    stiffness: a.stiffness,
+    damping: a.damping,
+    mass: a.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!b(t, P) && b(t, L))
+    if (t.visualDuration) {
+      const s = t.visualDuration, u = 2 * Math.PI / (s * 1.2), m = u * u, h = 2 * I(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(m);
+      n = {
+        ...n,
+        mass: a.mass,
+        stiffness: m,
+        damping: h
+      };
+    } else {
+      const s = V(t);
+      n = {
+        ...n,
+        ...s,
+        mass: a.mass
+      }, n.isResolvedFromDuration = !0;
+    }
+  return n;
+}
+function x(t = a.visualDuration, n = a.bounce) {
+  const s = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: n
+  } : t;
+  let { restSpeed: u, restDelta: m } = s;
+  const h = s.keyframes[0], f = s.keyframes[s.keyframes.length - 1], d = { done: !1, value: h }, { stiffness: M, damping: G, mass: D, duration: S, velocity: R, isResolvedFromDuration: q } = z({
+    ...s,
+    velocity: -T(s.velocity || 0)
+  }), p = R || 0, o = G / (2 * Math.sqrt(M * D)), c = f - h, i = T(Math.sqrt(M / D)), F = Math.abs(c) < 5;
+  u || (u = F ? a.restSpeed.granular : a.restSpeed.default), m || (m = F ? a.restDelta.granular : a.restDelta.default);
+  let g;
+  if (o < 1) {
+    const e = j(i, o);
+    g = (r) => {
+      const l = Math.exp(-o * i * r);
+      return f - l * ((p + o * i * c) / e * Math.sin(e * r) + c * Math.cos(e * r));
+    };
+  } else if (o === 1)
+    g = (e) => f - Math.exp(-i * e) * (c + (p + i * c) * e);
+  else {
+    const e = i * Math.sqrt(o * o - 1);
+    g = (r) => {
+      const l = Math.exp(-o * i * r), y = Math.min(e * r, 300);
+      return f - l * ((p + o * i * c) * Math.sinh(y) + e * c * Math.cosh(y)) / e;
+    };
+  }
+  const v = {
+    calculatedDuration: q && S || null,
+    next: (e) => {
+      const r = g(e);
+      if (q)
+        d.done = e >= S;
+      else {
+        let l = e === 0 ? p : 0;
+        o < 1 && (l = e === 0 ? k(p) : O(g, e, r));
+        const y = Math.abs(l) <= u, A = Math.abs(f - r) <= m;
+        d.done = y && A;
+      }
+      return d.value = d.done ? f : r, d;
+    },
+    toString: () => {
+      const e = Math.min(B(v), E), r = w((l) => v.next(e * l).value, e, 30);
+      return e + "ms " + r;
+    },
+    toTransition: () => {
+    }
+  };
+  return v;
+}
+x.applyToOptions = (t) => {
+  const n = K(t, 100, x);
+  return t.ease = n.ease, t.duration = k(n.duration), t.type = "keyframes", t;
+};
+export {
+  x as spring
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs

@@ -0,0 +1,13 @@
+import { calcGeneratorDuration as i, maxGeneratorDuration as m } from "./calc-duration.mjs";
+import { millisecondsToSeconds as s } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.mjs";
+function f(n, r = 100, o) {
+  const e = o({ ...n, keyframes: [0, r] }), t = Math.min(i(e), m);
+  return {
+    type: "keyframes",
+    ease: (a) => e.next(t * a).value / r,
+    duration: s(t)
+  };
+}
+export {
+  f as createGeneratorEasing
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs

@@ -0,0 +1,9 @@
+import { velocityPerSecond as c } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/velocity-per-second.mjs";
+const n = 5;
+function i(t, o, r) {
+  const e = Math.max(o - n, 0);
+  return c(r - t(e), o - e);
+}
+export {
+  i as calcGeneratorVelocity
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs

@@ -0,0 +1,46 @@
+import { AsyncMotionValueAnimation as A } from "../AsyncMotionValueAnimation.mjs";
+import { JSAnimation as k } from "../JSAnimation.mjs";
+import { getValueTransition as D } from "../utils/get-value-transition.mjs";
+import { makeAnimationInstant as d } from "../utils/make-animation-instant.mjs";
+import { getDefaultTransition as g } from "../utils/default-transitions.mjs";
+import { getFinalKeyframe as C } from "../utils/get-final-keyframe.mjs";
+import { isTransitionDefined as T } from "../utils/is-transition-defined.mjs";
+import { frame as V } from "../../frameloop/frame.mjs";
+import { secondsToMilliseconds as l } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.mjs";
+import { MotionGlobalConfig as y } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/global-config.mjs";
+const x = (a, t, r, m = {}, n, p) => (u) => {
+  const o = D(m, a) || {}, c = o.delay || m.delay || 0;
+  let { elapsed: s = 0 } = m;
+  s = s - l(c);
+  const e = {
+    keyframes: Array.isArray(r) ? r : [null, r],
+    ease: "easeOut",
+    velocity: t.getVelocity(),
+    ...o,
+    delay: -s,
+    onUpdate: (i) => {
+      t.set(i), o.onUpdate && o.onUpdate(i);
+    },
+    onComplete: () => {
+      u(), o.onComplete && o.onComplete();
+    },
+    name: a,
+    motionValue: t,
+    element: p ? void 0 : n
+  };
+  T(o) || Object.assign(e, g(a, e)), e.duration && (e.duration = l(e.duration)), e.repeatDelay && (e.repeatDelay = l(e.repeatDelay)), e.from !== void 0 && (e.keyframes[0] = e.from);
+  let f = !1;
+  if ((e.type === !1 || e.duration === 0 && !e.repeatDelay) && (d(e), e.delay === 0 && (f = !0)), (y.instantAnimations || y.skipAnimations || n != null && n.shouldSkipAnimations) && (f = !0, d(e), e.delay = 0), e.allowFlatten = !o.type && !o.ease, f && !p && t.get() !== void 0) {
+    const i = C(e.keyframes, o);
+    if (i !== void 0) {
+      V.update(() => {
+        e.onUpdate(i), e.onComplete();
+      });
+      return;
+    }
+  }
+  return o.isSync ? new k(e) : new A(e);
+};
+export {
+  x as animateMotionValue
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs

@@ -0,0 +1,49 @@
+import { getValueTransition as y } from "../utils/get-value-transition.mjs";
+import { positionalKeys as S } from "../../render/utils/keys-position.mjs";
+import { setTarget as H } from "../../render/utils/setters.mjs";
+import { addValueToWillChange as B } from "../../value/will-change/add-will-change.mjs";
+import { getOptimisedAppearId as I } from "../optimized-appear/get-appear-id.mjs";
+import { animateMotionValue as P } from "./motion-value.mjs";
+import { frame as A } from "../../frameloop/frame.mjs";
+function R({ protectedKeys: t, needsAnimating: e }, n) {
+  const r = t.hasOwnProperty(n) && e[n] !== !0;
+  return e[n] = !1, r;
+}
+function b(t, e, { delay: n = 0, transitionOverride: r, type: d } = {}) {
+  let { transition: i = t.getDefaultTransition(), transitionEnd: s, ...m } = e;
+  const V = i == null ? void 0 : i.reduceMotion;
+  r && (i = r);
+  const c = [], p = d && t.animationState && t.animationState.getState()[d];
+  for (const o in m) {
+    const a = t.getValue(o, t.latestValues[o] ?? null), f = m[o];
+    if (f === void 0 || p && R(p, o))
+      continue;
+    const u = {
+      delay: n,
+      ...y(i || {}, o)
+    }, l = a.get();
+    if (l !== void 0 && !a.isAnimating && !Array.isArray(f) && f === l && !u.velocity)
+      continue;
+    let g = !1;
+    if (window.MotionHandoffAnimation) {
+      const h = I(t);
+      if (h) {
+        const M = window.MotionHandoffAnimation(h, o, A);
+        M !== null && (u.startTime = M, g = !0);
+      }
+    }
+    B(t, o);
+    const w = V ?? t.shouldReduceMotion;
+    a.start(P(o, a, f, w && S.has(o) ? { type: !1 } : u, t, g));
+    const T = a.animation;
+    T && c.push(T);
+  }
+  return s && Promise.all(c).then(() => {
+    A.update(() => {
+      s && H(t, s);
+    });
+  }), c;
+}
+export {
+  b as animateTarget
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-variant.mjs

@@ -0,0 +1,30 @@
+import { resolveVariant as l } from "../../render/utils/resolve-dynamic-variants.mjs";
+import { calcChildStagger as g } from "../utils/calc-child-stagger.mjs";
+import { animateTarget as C } from "./visual-element-target.mjs";
+function y(r, i, t = {}) {
+  var n;
+  const e = l(r, i, t.type === "exit" ? (n = r.presenceContext) == null ? void 0 : n.custom : void 0);
+  let { transition: o = r.getDefaultTransition() || {} } = e || {};
+  t.transitionOverride && (o = t.transitionOverride);
+  const a = e ? () => Promise.all(C(r, e, t)) : () => Promise.resolve(), s = r.variantChildren && r.variantChildren.size ? (f = 0) => {
+    const { delayChildren: d = 0, staggerChildren: m, staggerDirection: h } = o;
+    return P(r, i, f, d, m, h, t);
+  } : () => Promise.resolve(), { when: c } = o;
+  if (c) {
+    const [f, d] = c === "beforeChildren" ? [a, s] : [s, a];
+    return f().then(() => d());
+  } else
+    return Promise.all([a(), s(t.delay)]);
+}
+function P(r, i, t = 0, e = 0, o = 0, a = 1, s) {
+  const c = [];
+  for (const n of r.variantChildren)
+    n.notify("AnimationStart", i), c.push(y(n, i, {
+      ...s,
+      delay: t + (typeof e == "function" ? 0 : e) + g(r.variantChildren, n, e, o, a)
+    }).then(() => n.notify("AnimationComplete", i)));
+  return Promise.all(c);
+}
+export {
+  y as animateVariant
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.mjs

@@ -0,0 +1,69 @@
+import { positionalKeys as c } from "../../render/utils/keys-position.mjs";
+import { findDimensionValueType as h } from "../../value/types/dimensions.mjs";
+import { getVariableValue as g } from "../utils/css-variables-conversion.mjs";
+import { isCSSVariableToken as K, containsCSSVariable as p } from "../utils/is-css-variable.mjs";
+import { KeyframeResolver as v } from "./KeyframesResolver.mjs";
+import { isNone as V } from "./utils/is-none.mjs";
+import { makeNoneKeyframesAnimatable as S } from "./utils/make-none-animatable.mjs";
+import { positionalValues as m, isNumOrPxType as y } from "./utils/unit-conversion.mjs";
+class M extends v {
+  constructor(e, n, r, t, o) {
+    super(e, n, r, t, o, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: n, name: r } = this;
+    if (!n || !n.current)
+      return;
+    super.readKeyframes();
+    for (let s = 0; s < e.length; s++) {
+      let i = e[s];
+      if (typeof i == "string" && (i = i.trim(), K(i))) {
+        const d = g(i, n.current);
+        d !== void 0 && (e[s] = d), s === e.length - 1 && (this.finalKeyframe = i);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !c.has(r) || e.length !== 2)
+      return;
+    const [t, o] = e, a = h(t), f = h(o), l = p(t), u = p(o);
+    if (l !== u && m[r]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (a !== f)
+      if (y(a) && y(f))
+        for (let s = 0; s < e.length; s++) {
+          const i = e[s];
+          typeof i == "string" && (e[s] = parseFloat(i));
+        }
+      else m[r] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: n } = this, r = [];
+    for (let t = 0; t < e.length; t++)
+      (e[t] === null || V(e[t])) && r.push(t);
+    r.length && S(e, r, n);
+  }
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: n, name: r } = this;
+    if (!e || !e.current)
+      return;
+    r === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = m[r](e.measureViewportBox(), window.getComputedStyle(e.current)), n[0] = this.measuredOrigin;
+    const t = n[n.length - 1];
+    t !== void 0 && e.getValue(r, t).jump(t, !1);
+  }
+  measureEndState() {
+    var f;
+    const { element: e, name: n, unresolvedKeyframes: r } = this;
+    if (!e || !e.current)
+      return;
+    const t = e.getValue(n);
+    t && t.jump(this.measuredOrigin, !1);
+    const o = r.length - 1, a = r[o];
+    r[o] = m[n](e.measureViewportBox(), window.getComputedStyle(e.current)), a !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = a), (f = this.removedTransforms) != null && f.length && this.removedTransforms.forEach(([l, u]) => {
+      e.getValue(l).set(u);
+    }), this.resolveNoneKeyframes();
+  }
+}
+export {
+  M as DOMKeyframesResolver
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs

@@ -0,0 +1,75 @@
+import { fillWildcards as y } from "./utils/fill-wildcards.mjs";
+import { removeNonTranslationalTransform as p } from "./utils/unit-conversion.mjs";
+import { frame as c } from "../../frameloop/frame.mjs";
+const l = /* @__PURE__ */ new Set();
+let o = !1, d = !1, m = !1;
+function u() {
+  if (d) {
+    const r = Array.from(l).filter((e) => e.needsMeasurement), s = new Set(r.map((e) => e.element)), a = /* @__PURE__ */ new Map();
+    s.forEach((e) => {
+      const t = p(e);
+      t.length && (a.set(e, t), e.render());
+    }), r.forEach((e) => e.measureInitialState()), s.forEach((e) => {
+      e.render();
+      const t = a.get(e);
+      t && t.forEach(([n, i]) => {
+        var f;
+        (f = e.getValue(n)) == null || f.set(i);
+      });
+    }), r.forEach((e) => e.measureEndState()), r.forEach((e) => {
+      e.suspendedScrollY !== void 0 && window.scrollTo(0, e.suspendedScrollY);
+    });
+  }
+  d = !1, o = !1, l.forEach((r) => r.complete(m)), l.clear();
+}
+function h() {
+  l.forEach((r) => {
+    r.readKeyframes(), r.needsMeasurement && (d = !0);
+  });
+}
+function S() {
+  m = !0, h(), u(), m = !1;
+}
+class g {
+  constructor(s, a, e, t, n, i = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...s], this.onComplete = a, this.name = e, this.motionValue = t, this.element = n, this.isAsync = i;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (l.add(this), o || (o = !0, c.read(h), c.resolveKeyframes(u))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: s, name: a, element: e, motionValue: t } = this;
+    if (s[0] === null) {
+      const n = t == null ? void 0 : t.get(), i = s[s.length - 1];
+      if (n !== void 0)
+        s[0] = n;
+      else if (e && a) {
+        const f = e.readValue(a, i);
+        f != null && (s[0] = f);
+      }
+      s[0] === void 0 && (s[0] = i), t && n === void 0 && t.set(s[0]);
+    }
+    y(s);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(s = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, s), l.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (l.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
+}
+export {
+  g as KeyframeResolver,
+  S as flushKeyframeResolvers
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.mjs

@@ -0,0 +1,12 @@
+import { mixNumber as e } from "../../../utils/mix/number.mjs";
+import { progress as f } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/progress.mjs";
+function l(o, t) {
+  const s = o[o.length - 1];
+  for (let r = 1; r <= t; r++) {
+    const m = f(0, t, r);
+    o.push(e(s, 1, m));
+  }
+}
+export {
+  l as fillOffset
+};