@t-headless-ui/react 1.1.1 → 1.1.3

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs

@@ -0,0 +1,53 @@
+"use client";
+import { useContext as C } from "react";
+import { MotionContext as x } from "../../context/MotionContext/index.mjs";
+import { PresenceContext as S } from "../../context/PresenceContext.mjs";
+import { useConstant as h } from "../../utils/use-constant.mjs";
+import { resolveMotionValue as M } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/utils/resolve-motion-value.mjs";
+import { isControllingVariants as N, isVariantNode as P } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.mjs";
+import { isAnimationControls as T } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.mjs";
+import { resolveVariantFromProps as $ } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/resolve-variants.mjs";
+function b({ scrapeMotionValuesFromProps: t, createRenderState: i }, e, s, n) {
+  return {
+    latestValues: p(e, s, n, t),
+    renderState: i()
+  };
+}
+function p(t, i, e, s) {
+  const n = {}, o = s(t, {});
+  for (const l in o)
+    n[l] = M(o[l]);
+  let { initial: m, animate: u } = t;
+  const g = N(t), v = P(t);
+  i && v && !g && t.inherit !== !1 && (m === void 0 && (m = i.initial), u === void 0 && (u = i.animate));
+  let c = e ? e.initial === !1 : !1;
+  c = c || m === !1;
+  const a = c ? u : m;
+  if (a && typeof a != "boolean" && !T(a)) {
+    const l = Array.isArray(a) ? a : [a];
+    for (let d = 0; d < l.length; d++) {
+      const V = $(t, l[d]);
+      if (V) {
+        const { transitionEnd: k, transition: B, ...y } = V;
+        for (const f in y) {
+          let r = y[f];
+          if (Array.isArray(r)) {
+            const A = c ? r.length - 1 : 0;
+            r = r[A];
+          }
+          r !== null && (n[f] = r);
+        }
+        for (const f in k)
+          n[f] = k[f];
+      }
+    }
+  }
+  return n;
+}
+const z = (t) => (i, e) => {
+  const s = C(x), n = C(S), o = () => b(t, i, s, n);
+  return e ? o() : h(o);
+};
+export {
+  z as makeUseVisualState
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/components/create-proxy.mjs

@@ -0,0 +1,18 @@
+import { createMotionComponent as e } from "../../motion/index.mjs";
+import { warnOnce as a } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/warn-once.mjs";
+function u(r, c) {
+  if (typeof Proxy > "u")
+    return e;
+  const o = /* @__PURE__ */ new Map(), i = (n, t) => e(n, t, r, c), f = (n, t) => (process.env.NODE_ENV !== "production" && a(!1, "motion() is deprecated. Use motion.create() instead."), i(n, t));
+  return new Proxy(f, {
+    /**
+     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+     * The prop name is passed through as `key` and we can use that to generate a `motion`
+     * DOM component with that name.
+     */
+    get: (n, t) => t === "create" ? i : (o.has(t) || o.set(t, e(t, void 0, r, c)), o.get(t))
+  });
+}
+export {
+  u as createMotionProxy
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/components/motion/feature-bundle.mjs

@@ -0,0 +1,13 @@
+import { animations as o } from "../../../motion/features/animations.mjs";
+import { drag as r } from "../../../motion/features/drag.mjs";
+import { gestureAnimations as t } from "../../../motion/features/gestures.mjs";
+import { layout as m } from "../../../motion/features/layout.mjs";
+const f = {
+  ...o,
+  ...t,
+  ...r,
+  ...m
+};
+export {
+  f as featureBundle
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/components/motion/proxy.mjs

@@ -0,0 +1,7 @@
+import { createDomVisualElement as o } from "../../dom/create-visual-element.mjs";
+import { createMotionProxy as r } from "../create-proxy.mjs";
+import { featureBundle as t } from "./feature-bundle.mjs";
+const n = /* @__PURE__ */ r(t, o);
+export {
+  n as motion
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs

@@ -0,0 +1,10 @@
+import { Fragment as m } from "react";
+import { isSVGComponent as t } from "./utils/is-svg-component.mjs";
+import { SVGVisualElement as o } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/SVGVisualElement.mjs";
+import { HTMLVisualElement as i } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/HTMLVisualElement.mjs";
+const G = (r, e) => e.isSVG ?? t(r) ? new o(e) : new i(e, {
+  allowProjection: r !== m
+});
+export {
+  G as createDomVisualElement
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/dom/use-render.mjs

@@ -0,0 +1,17 @@
+"use client";
+import { Fragment as p, useMemo as P, createElement as a } from "react";
+import { useHTMLProps as d } from "../html/use-props.mjs";
+import { useSVGProps as V } from "../svg/use-props.mjs";
+import { filterProps as g } from "./utils/filter-props.mjs";
+import { isSVGComponent as h } from "./utils/is-svg-component.mjs";
+import { isMotionValue as M } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/utils/is-motion-value.mjs";
+function H(r, s, o, { latestValues: t }, i, n = !1, l) {
+  const m = (l ?? h(r) ? V : d)(s, t, i, r), u = g(s, typeof r == "string", n), c = r !== p ? { ...u, ...m, ref: o } : {}, { children: e } = s, f = P(() => M(e) ? e.get() : e, [e]);
+  return a(r, {
+    ...c,
+    children: f
+  });
+}
+export {
+  H as useRender
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs

@@ -0,0 +1,20 @@
+import { isValidMotionProp as e } from "../../../motion/utils/valid-prop.mjs";
+let i = (t) => !e(t);
+function f(t) {
+  typeof t == "function" && (i = (o) => o.startsWith("on") ? !e(o) : t(o));
+}
+try {
+  f(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function l(t, o, a) {
+  const n = {};
+  for (const r in t)
+    r === "values" && typeof t.values == "object" || (i(r) || a === !0 && e(r) || !o && !e(r) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && r.startsWith("onDrag")) && (n[r] = t[r]);
+  return n;
+}
+export {
+  l as filterProps,
+  f as loadExternalIsValidProp
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/html/use-html-visual-state.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { makeUseVisualState as e } from "../../motion/utils/use-visual-state.mjs";
+import { createHtmlRenderState as t } from "./utils/create-render-state.mjs";
+import { scrapeMotionValuesFromProps as r } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/utils/scrape-motion-values.mjs";
+const m = /* @__PURE__ */ e({
+  scrapeMotionValuesFromProps: r,
+  createRenderState: t
+});
+export {
+  m as useHTMLVisualState
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/html/use-props.mjs

@@ -0,0 +1,28 @@
+"use client";
+import { useMemo as i } from "react";
+import { createHtmlRenderState as a } from "./utils/create-render-state.mjs";
+import { isMotionValue as l } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/utils/is-motion-value.mjs";
+import { isForcedMotionValue as r } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/is-forced-motion-value.mjs";
+import { buildHTMLStyles as s } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/utils/build-styles.mjs";
+function u(t, o, n) {
+  for (const e in o)
+    !l(o[e]) && !r(e, n) && (t[e] = o[e]);
+}
+function c({ transformTemplate: t }, o) {
+  return i(() => {
+    const n = a();
+    return s(n, o, t), Object.assign({}, n.vars, n.style);
+  }, [o]);
+}
+function f(t, o) {
+  const n = t.style || {}, e = {};
+  return u(e, n, t), Object.assign(e, c(t, o)), e;
+}
+function M(t, o) {
+  const n = {}, e = f(t, o);
+  return t.drag && t.dragListener !== !1 && (n.draggable = !1, e.userSelect = e.WebkitUserSelect = e.WebkitTouchCallout = "none", e.touchAction = t.drag === !0 ? "none" : `pan-${t.drag === "x" ? "y" : "x"}`), t.tabIndex === void 0 && (t.onTap || t.onTapStart || t.whileTap) && (n.tabIndex = 0), n.style = e, n;
+}
+export {
+  u as copyRawValuesOnly,
+  M as useHTMLProps
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/svg/use-props.mjs

@@ -0,0 +1,23 @@
+"use client";
+import { useMemo as l } from "react";
+import { copyRawValuesOnly as m } from "../html/use-props.mjs";
+import { createSvgRenderState as i } from "./utils/create-render-state.mjs";
+import { buildSVGAttrs as n } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/utils/build-attrs.mjs";
+import { isSVGTag as a } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/utils/is-svg-tag.mjs";
+function G(e, s, y, o) {
+  const r = l(() => {
+    const t = i();
+    return n(t, s, a(o), e.transformTemplate, e.style), {
+      ...t.attrs,
+      style: { ...t.style }
+    };
+  }, [s]);
+  if (e.style) {
+    const t = {};
+    m(t, e.style, e), r.style = { ...t, ...r.style };
+  }
+  return r;
+}
+export {
+  G as useSVGProps
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/render/svg/use-svg-visual-state.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { makeUseVisualState as e } from "../../motion/utils/use-visual-state.mjs";
+import { createSvgRenderState as t } from "./utils/create-render-state.mjs";
+import { scrapeMotionValuesFromProps as r } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/utils/scrape-motion-values.mjs";
+const m = /* @__PURE__ */ e({
+  scrapeMotionValuesFromProps: r,
+  createRenderState: t
+});
+export {
+  m as useSVGVisualState
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/utils/reduced-motion/use-reduced-motion-config.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { useContext as t } from "react";
+import { MotionConfigContext as n } from "../../context/MotionConfigContext.mjs";
+import { useReducedMotion as r } from "./use-reduced-motion.mjs";
+function s() {
+  const o = r(), { reducedMotion: e } = t(n);
+  return e === "never" ? !1 : e === "always" ? !0 : o;
+}
+export {
+  s as useReducedMotionConfig
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/utils/reduced-motion/use-reduced-motion.mjs

@@ -0,0 +1,13 @@
+"use client";
+import { useState as o } from "react";
+import { hasReducedMotionListener as r, prefersReducedMotion as t } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/reduced-motion/state.mjs";
+import { initPrefersReducedMotion as n } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/reduced-motion/index.mjs";
+import { warnOnce as i } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/warn-once.mjs";
+function a() {
+  !r.current && n();
+  const [e] = o(t.current);
+  return process.env.NODE_ENV !== "production" && i(e !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled"), e;
+}
+export {
+  a as useReducedMotion
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/utils/use-composed-ref.mjs

@@ -0,0 +1,28 @@
+import * as l from "react";
+function f(n, u) {
+  if (typeof n == "function")
+    return n(u);
+  n != null && (n.current = u);
+}
+function i(...n) {
+  return (u) => {
+    let o = !1;
+    const c = n.map((e) => {
+      const t = f(e, u);
+      return !o && typeof t == "function" && (o = !0), t;
+    });
+    if (o)
+      return () => {
+        for (let e = 0; e < c.length; e++) {
+          const t = c[e];
+          typeof t == "function" ? t() : f(n[e], null);
+        }
+      };
+  };
+}
+function s(...n) {
+  return l.useCallback(i(...n), n);
+}
+export {
+  s as useComposedRefs
+};

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

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

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

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

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs

@@ -0,0 +1,8 @@
+"use client";
+import { useEffect as t } from "react";
+function n(e) {
+  return t(() => () => e(), []);
+}
+export {
+  n as useUnmountEffect
+};

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

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

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

@@ -0,0 +1,76 @@
+class l {
+  constructor(t) {
+    this.stop = () => this.runAll("stop"), this.animations = t.filter(Boolean);
+  }
+  get finished() {
+    return Promise.all(this.animations.map((t) => t.finished));
+  }
+  /**
+   * TODO: Filter out cancelled or stopped animations before returning
+   */
+  getAll(t) {
+    return this.animations[0][t];
+  }
+  setAll(t, e) {
+    for (let i = 0; i < this.animations.length; i++)
+      this.animations[i][t] = e;
+  }
+  attachTimeline(t) {
+    const e = this.animations.map((i) => i.attachTimeline(t));
+    return () => {
+      e.forEach((i, s) => {
+        i && i(), this.animations[s].stop();
+      });
+    };
+  }
+  get time() {
+    return this.getAll("time");
+  }
+  set time(t) {
+    this.setAll("time", t);
+  }
+  get speed() {
+    return this.getAll("speed");
+  }
+  set speed(t) {
+    this.setAll("speed", t);
+  }
+  get state() {
+    return this.getAll("state");
+  }
+  get startTime() {
+    return this.getAll("startTime");
+  }
+  get duration() {
+    return a(this.animations, "duration");
+  }
+  get iterationDuration() {
+    return a(this.animations, "iterationDuration");
+  }
+  runAll(t) {
+    this.animations.forEach((e) => e[t]());
+  }
+  play() {
+    this.runAll("play");
+  }
+  pause() {
+    this.runAll("pause");
+  }
+  cancel() {
+    this.runAll("cancel");
+  }
+  complete() {
+    this.runAll("complete");
+  }
+}
+function a(n, t) {
+  let e = 0;
+  for (let i = 0; i < n.length; i++) {
+    const s = n[i][t];
+    s !== null && s > e && (e = s);
+  }
+  return e;
+}
+export {
+  l as GroupAnimation
+};

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

@@ -0,0 +1,10 @@
+import { GroupAnimation as t } from "./GroupAnimation.mjs";
+class r extends t {
+  then(n, i) {
+    return this.finished.finally(n).then(() => {
+    });
+  }
+}
+export {
+  r as GroupAnimationWithThen
+};

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

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