@t-headless-ui/react 1.1.2 → 1.1.4

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
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/keyframes/utils/is-none.mjs

@@ -0,0 +1,7 @@
+import { isZeroValueString as n } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/is-zero-value-string.mjs";
+function t(r) {
+  return typeof r == "number" ? r === 0 : r !== null ? r === "none" || r === "0" || n(r) : !0;
+}
+export {
+  t as isNone
+};

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

@@ -0,0 +1,27 @@
+class t {
+  constructor() {
+    this.updateFinished();
+  }
+  get finished() {
+    return this._finished;
+  }
+  updateFinished() {
+    this._finished = new Promise((i) => {
+      this.resolve = i;
+    });
+  }
+  notifyFinished() {
+    this.resolve();
+  }
+  /**
+   * Allows the animation to be awaited.
+   *
+   * @deprecated Use `finished` instead.
+   */
+  then(i, e) {
+    return this.finished.then(i, e);
+  }
+}
+export {
+  t as WithPromise
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/utils/calc-child-stagger.mjs

@@ -0,0 +1,7 @@
+function x(t, s, c, o = 0, u = 1) {
+  const n = Array.from(t).sort((a, e) => a.sortNodePosition(e)).indexOf(s), i = t.size, r = (i - 1) * o;
+  return typeof c == "function" ? c(n, i) : u === 1 ? n * o : r - n * o;
+}
+export {
+  x as calcChildStagger
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/utils/can-animate.mjs

@@ -0,0 +1,23 @@
+import { isGenerator as f } from "../generators/utils/is-generator.mjs";
+import { isAnimatable as l } from "./is-animatable.mjs";
+import { warning as g } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/errors.mjs";
+function s(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 o = t[t.length - 1], a = l(r, i), e = l(o, i);
+  return g(a === e, `You are trying to animate ${i} from "${r}" to "${o}". "${a ? o : r}" is not an animatable value.`, "value-not-animatable"), !a || !e ? !1 : s(t) || (n === "spring" || f(n)) && u;
+}
+export {
+  h as canAnimate
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/utils/css-variables-conversion.mjs

@@ -0,0 +1,31 @@
+import { isCSSVariableToken as c } from "./is-css-variable.mjs";
+import { isNumericalString as l } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/is-numerical-string.mjs";
+import { invariant as s } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/errors.mjs";
+const m = (
+  // eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
+  /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u
+);
+function p(a) {
+  const e = m.exec(a);
+  if (!e)
+    return [,];
+  const [, r, i, t] = e;
+  return [`--${r ?? i}`, t];
+}
+const f = 4;
+function u(a, e, r = 1) {
+  s(r <= f, `Max CSS variable fallback depth detected in property "${a}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [i, t] = p(a);
+  if (!i)
+    return;
+  const o = window.getComputedStyle(e).getPropertyValue(i);
+  if (o) {
+    const n = o.trim();
+    return l(n) ? parseFloat(n) : n;
+  }
+  return c(t) ? u(t, e, r + 1) : t;
+}
+export {
+  u as getVariableValue,
+  p as parseCSSVariable
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/utils/default-transitions.mjs

@@ -0,0 +1,22 @@
+import { transformProps as s } from "../../render/utils/keys-transform.mjs";
+const r = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, n = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), i = {
+  type: "keyframes",
+  duration: 0.8
+}, a = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, o = (t, { keyframes: e }) => e.length > 2 ? i : s.has(t) ? t.startsWith("scale") ? n(e[1]) : r : a;
+export {
+  o as getDefaultTransition
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/utils/is-css-variable.mjs

@@ -0,0 +1,9 @@
+const r = (t) => (s) => typeof s == "string" && s.startsWith(t), e = /* @__PURE__ */ r("--"), i = /* @__PURE__ */ r("var(--"), a = (t) => i(t) ? n.test(t.split("/*")[0].trim()) : !1, n = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+function o(t) {
+  return typeof t != "string" ? !1 : t.split("/*")[0].includes("var(--");
+}
+export {
+  o as containsCSSVariable,
+  e as isCSSVariableName,
+  a as isCSSVariableToken
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/utils/make-animation-instant.mjs

@@ -0,0 +1,6 @@
+function t(n) {
+  n.duration = 0, n.type = "keyframes";
+}
+export {
+  t as makeAnimationInstant
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/waapi/easing/map-easing.mjs

@@ -0,0 +1,12 @@
+import { supportsLinearEasing as o } from "../../../utils/supports/linear-easing.mjs";
+import { generateLinearEasing as f } from "../utils/linear.mjs";
+import { cubicBezierAsString as n } from "./cubic-bezier.mjs";
+import { supportedWaapiEasing as i } from "./supported.mjs";
+import { isBezierDefinition as p } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/utils/is-bezier-definition.mjs";
+function m(r, e) {
+  if (r)
+    return typeof r == "function" ? o() ? f(r, e) : "ease-out" : p(r) ? n(r) : Array.isArray(r) ? r.map((t) => m(t, e) || i.easeOut) : i[r];
+}
+export {
+  m as mapEasingToNativeEasing
+};

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

@@ -0,0 +1,24 @@
+import { memo as m } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/memo.mjs";
+const l = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Could be re-enabled now we have support for linear() easing
+  // "background-color"
+]), f = /* @__PURE__ */ m(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function w(n) {
+  var r;
+  const { motionValue: e, name: t, repeatDelay: a, repeatType: o, damping: s, type: p } = n;
+  if (!(((r = e == null ? void 0 : e.owner) == null ? void 0 : r.current) instanceof HTMLElement))
+    return !1;
+  const { onUpdate: c, transformTemplate: i } = e.owner.getProps();
+  return f() && t && l.has(t) && (t !== "transform" || !i) && /**
+   * If we're outputting values to onUpdate then we can't use WAAPI as there's
+   * no way to read the value from WAAPI every frame.
+   */
+  !c && !a && o !== "mirror" && s !== 0 && p !== "inertia";
+}
+export {
+  w as supportsBrowserAnimation
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/waapi/utils/linear.mjs

@@ -0,0 +1,10 @@
+const i = (r, a, o = 10) => {
+  let n = "";
+  const e = Math.max(Math.round(a / o), 2);
+  for (let t = 0; t < e; t++)
+    n += Math.round(r(t / (e - 1)) * 1e4) / 1e4 + ", ";
+  return `linear(${n.substring(0, n.length - 2)})`;
+};
+export {
+  i as generateLinearEasing
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/waapi/utils/unsupported-easing.mjs

@@ -0,0 +1,17 @@
+import { circInOut as r } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/circ.mjs";
+import { backInOut as t } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/back.mjs";
+import { anticipate as o } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/anticipate.mjs";
+const n = {
+  anticipate: o,
+  backInOut: t,
+  circInOut: r
+};
+function p(e) {
+  return e in n;
+}
+function u(e) {
+  typeof e.ease == "string" && p(e.ease) && (e.ease = n[e.ease]);
+}
+export {
+  u as replaceStringEasing
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/frameloop/batcher.mjs

@@ -0,0 +1,27 @@
+import { stepsOrder as o } from "./order.mjs";
+import { createRenderStep as b } from "./render-step.mjs";
+import { MotionGlobalConfig as i } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/global-config.mjs";
+const v = 40;
+function N(c, l) {
+  let r = !1, a = !0;
+  const e = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  }, m = () => r = !0, n = o.reduce((s, t) => (s[t] = b(m), s), {}), { setup: u, read: f, resolveKeyframes: d, preUpdate: g, update: h, preRender: M, render: R, postRender: x } = n, p = () => {
+    const s = i.useManualTiming ? e.timestamp : performance.now();
+    r = !1, i.useManualTiming || (e.delta = a ? 1e3 / 60 : Math.max(Math.min(s - e.timestamp, v), 1)), e.timestamp = s, e.isProcessing = !0, u.process(e), f.process(e), d.process(e), g.process(e), h.process(e), M.process(e), R.process(e), x.process(e), e.isProcessing = !1, r && l && (a = !1, c(p));
+  }, P = () => {
+    r = !0, a = !0, e.isProcessing || c(p);
+  };
+  return { schedule: o.reduce((s, t) => {
+    const w = n[t];
+    return s[t] = (E, F = !1, T = !1) => (r || P(), w.schedule(E, F, T)), s;
+  }, {}), cancel: (s) => {
+    for (let t = 0; t < o.length; t++)
+      n[o[t]].cancel(s);
+  }, state: e, steps: n };
+}
+export {
+  N as createRenderBatcher
+};

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

@@ -0,0 +1,9 @@
+import { createRenderBatcher as e } from "./batcher.mjs";
+import { noop as r } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/noop.mjs";
+const { schedule: m, cancel: n, state: o, steps: c } = /* @__PURE__ */ e(typeof requestAnimationFrame < "u" ? requestAnimationFrame : r, !0);
+export {
+  n as cancelFrame,
+  m as frame,
+  o as frameData,
+  c as frameSteps
+};