@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/components/AnimatePresence/PresenceChild.mjs

@@ -0,0 +1,35 @@
+"use client";
+import { jsx as a } from "react/jsx-runtime";
+import * as M from "react";
+import { useId as w, useMemo as c } from "react";
+import { PresenceContext as x } from "../../context/PresenceContext.mjs";
+import { useConstant as R } from "../../utils/use-constant.mjs";
+import { PopChild as g } from "./PopChild.mjs";
+const _ = ({ children: n, initial: p, isPresent: r, onExitComplete: o, custom: i, presenceAffectsLayout: m, mode: l, anchorX: d, anchorY: h, root: C }) => {
+  const e = R(j), v = w();
+  let u = !0, s = c(() => (u = !1, {
+    id: v,
+    initial: p,
+    isPresent: r,
+    custom: i,
+    onExitComplete: (t) => {
+      e.set(t, !0);
+      for (const f of e.values())
+        if (!f)
+          return;
+      o && o();
+    },
+    register: (t) => (e.set(t, !1), () => e.delete(t))
+  }), [r, e, o]);
+  return m && u && (s = { ...s }), c(() => {
+    e.forEach((t, f) => e.set(f, !1));
+  }, [r]), M.useEffect(() => {
+    !r && !e.size && o && o();
+  }, [r]), n = a(g, { pop: l === "popLayout", isPresent: r, anchorX: d, anchorY: h, root: C, children: n }), a(x.Provider, { value: s, children: n });
+};
+function j() {
+  return /* @__PURE__ */ new Map();
+}
+export {
+  _ as PresenceChild
+};

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/components/AnimatePresence/index.mjs

@@ -0,0 +1,48 @@
+"use client";
+import { jsx as k, Fragment as Y } from "react/jsx-runtime";
+import { useMemo as F, useRef as p, useState as v, useContext as G } from "react";
+import { LayoutGroupContext as O } from "../../context/LayoutGroupContext.mjs";
+import { useConstant as R } from "../../utils/use-constant.mjs";
+import { useIsomorphicLayoutEffect as V } from "../../utils/use-isomorphic-effect.mjs";
+import { PresenceChild as X } from "./PresenceChild.mjs";
+import { usePresence as _ } from "./use-presence.mjs";
+import { onlyElements as A, getChildKey as c } from "./utils.mjs";
+const W = ({ children: C, custom: L, initial: b = !0, onExitComplete: y, presenceAffectsLayout: j = !0, mode: u = "sync", propagate: l = !1, anchorX: D = "left", anchorY: I = "top", root: K }) => {
+  const [x, f] = _(l), n = F(() => A(C), [C]), o = l && !x ? [] : n.map(c), g = p(!0), P = p(n), i = R(() => /* @__PURE__ */ new Map()), d = p(/* @__PURE__ */ new Set()), [M, N] = v(n), [r, w] = v(n);
+  V(() => {
+    g.current = !1, P.current = n;
+    for (let t = 0; t < r.length; t++) {
+      const e = c(r[t]);
+      o.includes(e) ? (i.delete(e), d.current.delete(e)) : i.get(e) !== !0 && i.set(e, !1);
+    }
+  }, [r, o.length, o.join("-")]);
+  const m = [];
+  if (n !== M) {
+    let t = [...n];
+    for (let e = 0; e < r.length; e++) {
+      const s = r[e], h = c(s);
+      o.includes(h) || (t.splice(e, 0, s), m.push(s));
+    }
+    return u === "wait" && m.length && (t = m), w(A(t)), N(n), null;
+  }
+  process.env.NODE_ENV !== "production" && u === "wait" && r.length > 1 && console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+  const { forceRender: a } = G(O);
+  return k(Y, { children: r.map((t) => {
+    const e = c(t), s = l && !x ? !1 : n === r || o.includes(e), h = () => {
+      if (d.current.has(e))
+        return;
+      if (d.current.add(e), i.has(e))
+        i.set(e, !0);
+      else
+        return;
+      let E = !0;
+      i.forEach((S) => {
+        S || (E = !1);
+      }), E && (a == null || a(), w(P.current), l && (f == null || f()), y && y());
+    };
+    return k(X, { isPresent: s, initial: !g.current || b ? void 0 : !1, custom: L, presenceAffectsLayout: j, mode: u, root: K, onExitComplete: s ? void 0 : h, anchorX: D, anchorY: I, children: t }, e);
+  }) });
+};
+export {
+  W as AnimatePresence
+};

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/components/AnimatePresence/use-presence.mjs

@@ -0,0 +1,18 @@
+"use client";
+import { useContext as f, useId as l, useEffect as c, useCallback as i } from "react";
+import { PresenceContext as m } from "../../context/PresenceContext.mjs";
+function p(e = !0) {
+  const o = f(m);
+  if (o === null)
+    return [!0, null];
+  const { isPresent: r, onExitComplete: t, register: u } = o, n = l();
+  c(() => {
+    if (e)
+      return u(n);
+  }, [e]);
+  const s = i(() => e && t && t(n), [n, t, e]);
+  return !r && t ? [!1, s] : [!0];
+}
+export {
+  p as usePresence
+};

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/context/MotionContext/create.mjs

@@ -0,0 +1,14 @@
+"use client";
+import { useContext as o, useMemo as i } from "react";
+import { MotionContext as a } from "./index.mjs";
+import { getCurrentTreeVariants as s } from "./utils.mjs";
+function f(t) {
+  const { initial: e, animate: n } = s(t, o(a));
+  return i(() => ({ initial: e, animate: n }), [r(e), r(n)]);
+}
+function r(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+export {
+  f as useCreateMotionContext
+};

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/context/MotionContext/utils.mjs

@@ -0,0 +1,15 @@
+import { isControllingVariants as r } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.mjs";
+import { isVariantLabel as e } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/is-variant-label.mjs";
+function o(i, a) {
+  if (r(i)) {
+    const { initial: n, animate: t } = i;
+    return {
+      initial: n === !1 || e(n) ? n : void 0,
+      animate: e(t) ? t : void 0
+    };
+  }
+  return i.inherit !== !1 ? a : {};
+}
+export {
+  o as getCurrentTreeVariants
+};

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/events/add-pointer-event.mjs

@@ -0,0 +1,8 @@
+import { addPointerInfo as d } from "./event-info.mjs";
+import { addDomEvent as e } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/events/add-dom-event.mjs";
+function f(o, r, t, n) {
+  return e(o, r, d(t), n);
+}
+export {
+  f as addPointerEvent
+};

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/events/event-info.mjs

@@ -0,0 +1,14 @@
+import { isPrimaryPointer as t } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs";
+function n(r) {
+  return {
+    point: {
+      x: r.pageX,
+      y: r.pageY
+    }
+  };
+}
+const a = (r) => (o) => t(o) && r(o, n(o));
+export {
+  a as addPointerInfo,
+  n as extractEventInfo
+};

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/gestures/drag/VisualElementDragControls.mjs

@@ -0,0 +1,296 @@
+import { addPointerEvent as k } from "../../events/add-pointer-event.mjs";
+import { extractEventInfo as B } from "../../events/event-info.mjs";
+import { getContextWindow as j } from "../../utils/get-context-window.mjs";
+import { isRefObject as P } from "../../utils/is-ref-object.mjs";
+import { PanSession as T } from "../pan/PanSession.mjs";
+import { applyConstraints as b, calcRelativeConstraints as I, resolveDragElastic as w, calcViewportConstraints as R, defaultElastic as W, rebaseAxisConstraints as O, calcOrigin as z } from "./utils/constraints.mjs";
+import { createBox as F } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/geometry/models.mjs";
+import { frame as C } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/frameloop/frame.mjs";
+import { eachAxis as g } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/utils/each-axis.mjs";
+import { invariant as U } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/errors.mjs";
+import { measurePageBox as _ } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/utils/measure.mjs";
+import { convertBoxToBoundingBox as K, convertBoundingBoxToBox as N } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/geometry/conversion.mjs";
+import { addValueToWillChange as V } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/will-change/add-will-change.mjs";
+import { animateMotionValue as $ } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs";
+import { addDomEvent as q } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/events/add-dom-event.mjs";
+import { setDragLock as G } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/gestures/drag/state/set-active.mjs";
+import { resize as L } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/resize/index.mjs";
+import { percent as H } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/types/numbers/units.mjs";
+import { calcLength as J } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/geometry/delta-calc.mjs";
+import { mixNumber as M } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/utils/mix/number.mjs";
+import { isElementTextInput as Q } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.mjs";
+const X = /* @__PURE__ */ new WeakMap();
+class At {
+  constructor(t) {
+    this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = F(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = t;
+  }
+  start(t, { snapToCursor: s = !1, distanceThreshold: n } = {}) {
+    const { presenceContext: i } = this.visualElement;
+    if (i && i.isPresent === !1)
+      return;
+    const o = (r) => {
+      s ? (this.stopAnimation(), this.snapToCursor(B(r).point)) : this.pauseAnimation();
+    }, e = (r, a) => {
+      this.stopAnimation();
+      const { drag: p, dragPropagation: d, onDragStart: v } = this.getProps();
+      if (p && !d && (this.openDragLock && this.openDragLock(), this.openDragLock = G(p), !this.openDragLock))
+        return;
+      this.latestPointerEvent = r, this.latestPanInfo = a, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), g((f) => {
+        let D = this.getAxisMotionValue(f).get() || 0;
+        if (H.test(D)) {
+          const { projection: y } = this.visualElement;
+          if (y && y.layout) {
+            const x = y.layout.layoutBox[f];
+            x && (D = J(x) * (parseFloat(D) / 100));
+          }
+        }
+        this.originPoint[f] = D;
+      }), v && C.update(() => v(r, a), !1, !0), V(this.visualElement, "transform");
+      const { animationState: E } = this.visualElement;
+      E && E.setActive("whileDrag", !0);
+    }, l = (r, a) => {
+      this.latestPointerEvent = r, this.latestPanInfo = a;
+      const { dragPropagation: p, dragDirectionLock: d, onDirectionLock: v, onDrag: E } = this.getProps();
+      if (!p && !this.openDragLock)
+        return;
+      const { offset: f } = a;
+      if (d && this.currentDirection === null) {
+        this.currentDirection = Z(f), this.currentDirection !== null && v && v(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", a.point, f), this.updateAxis("y", a.point, f), this.visualElement.render(), E && C.update(() => E(r, a), !1, !0);
+    }, u = (r, a) => {
+      this.latestPointerEvent = r, this.latestPanInfo = a, this.stop(r, a), this.latestPointerEvent = null, this.latestPanInfo = null;
+    }, c = () => g((r) => {
+      var a;
+      return this.getAnimationState(r) === "paused" && ((a = this.getAxisMotionValue(r).animation) == null ? void 0 : a.play());
+    }), { dragSnapToOrigin: m } = this.getProps();
+    this.panSession = new T(t, {
+      onSessionStart: o,
+      onStart: e,
+      onMove: l,
+      onSessionEnd: u,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: m,
+      distanceThreshold: n,
+      contextWindow: j(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  /**
+   * @internal
+   */
+  stop(t, s) {
+    const n = t || this.latestPointerEvent, i = s || this.latestPanInfo, o = this.isDragging;
+    if (this.cancel(), !o || !i || !n)
+      return;
+    const { velocity: e } = i;
+    this.startAnimation(e);
+    const { onDragEnd: l } = this.getProps();
+    l && C.postRender(() => l(n, i));
+  }
+  /**
+   * @internal
+   */
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: s } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.endPanSession();
+    const { dragPropagation: n } = this.getProps();
+    !n && this.openDragLock && (this.openDragLock(), this.openDragLock = null), s && s.setActive("whileDrag", !1);
+  }
+  /**
+   * Clean up the pan session without modifying other drag state.
+   * This is used during unmount to ensure event listeners are removed
+   * without affecting projection animations or drag locks.
+   * @internal
+   */
+  endPanSession() {
+    this.panSession && this.panSession.end(), this.panSession = void 0;
+  }
+  updateAxis(t, s, n) {
+    const { drag: i } = this.getProps();
+    if (!n || !A(t, i, this.currentDirection))
+      return;
+    const o = this.getAxisMotionValue(t);
+    let e = this.originPoint[t] + n[t];
+    this.constraints && this.constraints[t] && (e = b(e, this.constraints[t], this.elastic[t])), o.set(e);
+  }
+  resolveConstraints() {
+    var o;
+    const { dragConstraints: t, dragElastic: s } = this.getProps(), n = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : (o = this.visualElement.projection) == null ? void 0 : o.layout, i = this.constraints;
+    t && P(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && n ? this.constraints = I(n.layoutBox, t) : this.constraints = !1, this.elastic = w(s), i !== this.constraints && !P(t) && n && this.constraints && !this.hasMutatedConstraints && g((e) => {
+      this.constraints !== !1 && this.getAxisMotionValue(e) && (this.constraints[e] = O(n.layoutBox[e], this.constraints[e]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: s } = this.getProps();
+    if (!t || !P(t))
+      return !1;
+    const n = t.current;
+    U(n !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+    const { projection: i } = this.visualElement;
+    if (!i || !i.layout)
+      return !1;
+    const o = _(n, i.root, this.visualElement.getTransformPagePoint());
+    let e = R(i.layout.layoutBox, o);
+    if (s) {
+      const l = s(K(e));
+      this.hasMutatedConstraints = !!l, l && (e = N(l));
+    }
+    return e;
+  }
+  startAnimation(t) {
+    const { drag: s, dragMomentum: n, dragElastic: i, dragTransition: o, dragSnapToOrigin: e, onDragTransitionEnd: l } = this.getProps(), u = this.constraints || {}, c = g((m) => {
+      if (!A(m, s, this.currentDirection))
+        return;
+      let r = u && u[m] || {};
+      e && (r = { min: 0, max: 0 });
+      const a = i ? 200 : 1e6, p = i ? 40 : 1e7, d = {
+        type: "inertia",
+        velocity: n ? t[m] : 0,
+        bounceStiffness: a,
+        bounceDamping: p,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...o,
+        ...r
+      };
+      return this.startAxisValueAnimation(m, d);
+    });
+    return Promise.all(c).then(l);
+  }
+  startAxisValueAnimation(t, s) {
+    const n = this.getAxisMotionValue(t);
+    return V(this.visualElement, t), n.start($(t, n, 0, s, this.visualElement, !1));
+  }
+  stopAnimation() {
+    g((t) => this.getAxisMotionValue(t).stop());
+  }
+  pauseAnimation() {
+    g((t) => {
+      var s;
+      return (s = this.getAxisMotionValue(t).animation) == null ? void 0 : s.pause();
+    });
+  }
+  getAnimationState(t) {
+    var s;
+    return (s = this.getAxisMotionValue(t).animation) == null ? void 0 : s.state;
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(t) {
+    const s = `_drag${t.toUpperCase()}`, n = this.visualElement.getProps(), i = n[s];
+    return i || this.visualElement.getValue(t, (n.initial ? n.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    g((s) => {
+      const { drag: n } = this.getProps();
+      if (!A(s, n, this.currentDirection))
+        return;
+      const { projection: i } = this.visualElement, o = this.getAxisMotionValue(s);
+      if (i && i.layout) {
+        const { min: e, max: l } = i.layout.layoutBox[s], u = o.get() || 0;
+        o.set(t[s] - M(e, l, 0.5) + u);
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag: t, dragConstraints: s } = this.getProps(), { projection: n } = this.visualElement;
+    if (!P(s) || !n || !this.constraints)
+      return;
+    this.stopAnimation();
+    const i = { x: 0, y: 0 };
+    g((e) => {
+      const l = this.getAxisMotionValue(e);
+      if (l && this.constraints !== !1) {
+        const u = l.get();
+        i[e] = z({ min: u, max: u }, this.constraints[e]);
+      }
+    });
+    const { transformTemplate: o } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = o ? o({}, "") : "none", n.root && n.root.updateScroll(), n.updateLayout(), this.constraints = !1, this.resolveConstraints(), g((e) => {
+      if (!A(e, t, null))
+        return;
+      const l = this.getAxisMotionValue(e), { min: u, max: c } = this.constraints[e];
+      l.set(M(u, c, i[e]));
+    }), this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    X.set(this.visualElement, this);
+    const t = this.visualElement.current, s = k(t, "pointerdown", (c) => {
+      const { drag: m, dragListener: r = !0 } = this.getProps(), a = c.target, p = a !== t && Q(a);
+      m && r && !p && this.start(c);
+    });
+    let n;
+    const i = () => {
+      const { dragConstraints: c } = this.getProps();
+      P(c) && c.current && (this.constraints = this.resolveRefConstraints(), n || (n = Y(t, c.current, () => this.scalePositionWithinConstraints())));
+    }, { projection: o } = this.visualElement, e = o.addEventListener("measure", i);
+    o && !o.layout && (o.root && o.root.updateScroll(), o.updateLayout()), C.read(i);
+    const l = q(window, "resize", () => this.scalePositionWithinConstraints()), u = o.addEventListener("didUpdate", (({ delta: c, hasLayoutChanged: m }) => {
+      this.isDragging && m && (g((r) => {
+        const a = this.getAxisMotionValue(r);
+        a && (this.originPoint[r] += c[r].translate, a.set(a.get() + c[r].translate));
+      }), this.visualElement.render());
+    }));
+    return () => {
+      l(), s(), e(), u && u(), n && n();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: s = !1, dragDirectionLock: n = !1, dragPropagation: i = !1, dragConstraints: o = !1, dragElastic: e = W, dragMomentum: l = !0 } = t;
+    return {
+      ...t,
+      drag: s,
+      dragDirectionLock: n,
+      dragPropagation: i,
+      dragConstraints: o,
+      dragElastic: e,
+      dragMomentum: l
+    };
+  }
+}
+function S(h) {
+  let t = !0;
+  return () => {
+    if (t) {
+      t = !1;
+      return;
+    }
+    h();
+  };
+}
+function Y(h, t, s) {
+  const n = L(h, S(s)), i = L(t, S(s));
+  return () => {
+    n(), i();
+  };
+}
+function A(h, t, s) {
+  return (t === !0 || t === h) && (s === null || s === h);
+}
+function Z(h, t = 10) {
+  let s = null;
+  return Math.abs(h.y) > t ? s = "y" : Math.abs(h.x) > t && (s = "x"), s;
+}
+export {
+  At as VisualElementDragControls,
+  X as elementDragControls
+};

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/gestures/drag/index.mjs

@@ -0,0 +1,22 @@
+import { VisualElementDragControls as t } from "./VisualElementDragControls.mjs";
+import { Feature as e } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+import { noop as s } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/noop.mjs";
+class m extends e {
+  constructor(o) {
+    super(o), this.removeGroupControls = s, this.removeListeners = s, this.controls = new t(o);
+  }
+  mount() {
+    const { dragControls: o } = this.node.getProps();
+    o && (this.removeGroupControls = o.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || s;
+  }
+  update() {
+    const { dragControls: o } = this.node.getProps(), { dragControls: r } = this.node.prevProps || {};
+    o !== r && (this.removeGroupControls(), o && (this.removeGroupControls = o.subscribe(this.controls)));
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession();
+  }
+}
+export {
+  m as DragGesture
+};

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/gestures/drag/utils/constraints.mjs

@@ -0,0 +1,67 @@
+import { mixNumber as r } from "../../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/utils/mix/number.mjs";
+import { calcLength as t } from "../../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/geometry/delta-calc.mjs";
+import { progress as u } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/progress.mjs";
+import { clamp as C } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.mjs";
+function a(n, { min: e, max: m }, i) {
+  return e !== void 0 && n < e ? n = i ? r(e, n, i.min) : Math.max(n, e) : m !== void 0 && n > m && (n = i ? r(m, n, i.max) : Math.min(n, m)), n;
+}
+function o(n, e, m) {
+  return {
+    min: e !== void 0 ? n.min + e : void 0,
+    max: m !== void 0 ? n.max + m - (n.max - n.min) : void 0
+  };
+}
+function L(n, { top: e, left: m, bottom: i, right: f }) {
+  return {
+    x: o(n.x, m, f),
+    y: o(n.y, e, i)
+  };
+}
+function x(n, e) {
+  let m = e.min - n.min, i = e.max - n.max;
+  return e.max - e.min < n.max - n.min && ([m, i] = [i, m]), { min: m, max: i };
+}
+function w(n, e) {
+  return {
+    x: x(n.x, e.x),
+    y: x(n.y, e.y)
+  };
+}
+function y(n, e) {
+  let m = 0.5;
+  const i = t(n), f = t(e);
+  return f > i ? m = u(e.min, e.max - i, n.min) : i > f && (m = u(n.min, n.max - f, e.min)), C(0, 1, m);
+}
+function M(n, e) {
+  const m = {};
+  return e.min !== void 0 && (m.min = e.min - n.min), e.max !== void 0 && (m.max = e.max - n.min), m;
+}
+const c = 0.35;
+function R(n = c) {
+  return n === !1 ? n = 0 : n === !0 && (n = c), {
+    x: l(n, "left", "right"),
+    y: l(n, "top", "bottom")
+  };
+}
+function l(n, e, m) {
+  return {
+    min: d(n, e),
+    max: d(n, m)
+  };
+}
+function d(n, e) {
+  return typeof n == "number" ? n : n[e] || 0;
+}
+export {
+  a as applyConstraints,
+  y as calcOrigin,
+  o as calcRelativeAxisConstraints,
+  L as calcRelativeConstraints,
+  x as calcViewportAxisConstraints,
+  w as calcViewportConstraints,
+  c as defaultElastic,
+  M as rebaseAxisConstraints,
+  l as resolveAxisElastic,
+  R as resolveDragElastic,
+  d as resolvePointElastic
+};

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/gestures/focus.mjs

@@ -0,0 +1,28 @@
+import { Feature as i } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+import { pipe as s } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/pipe.mjs";
+import { addDomEvent as e } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/events/add-dom-event.mjs";
+class a extends i {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let t = !1;
+    try {
+      t = this.node.current.matches(":focus-visible");
+    } catch {
+      t = !0;
+    }
+    !t || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = s(e(this.node.current, "focus", () => this.onFocus()), e(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+export {
+  a as FocusGesture
+};

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/gestures/hover.mjs

@@ -0,0 +1,21 @@
+import { extractEventInfo as m } from "../events/event-info.mjs";
+import { Feature as s } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+import { hover as u } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/gestures/hover.mjs";
+import { frame as c } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/frameloop/frame.mjs";
+function a(e, t, r) {
+  const { props: o } = e;
+  e.animationState && o.whileHover && e.animationState.setActive("whileHover", r === "Start");
+  const n = "onHover" + r, i = o[n];
+  i && c.postRender(() => i(t, m(t)));
+}
+class d extends s {
+  mount() {
+    const { current: t } = this.node;
+    t && (this.unmount = u(t, (r, o) => (a(this.node, o, "Start"), (n) => a(this.node, n, "End"))));
+  }
+  unmount() {
+  }
+}
+export {
+  d as HoverGesture
+};