@t-headless-ui/react 1.0.0

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs

@@ -0,0 +1,256 @@
+import { animateMotionValue as L } from "../../animation/interfaces/motion-value.mjs";
+import { addDomEvent as M } from "../../events/add-dom-event.mjs";
+import { addPointerEvent as S } from "../../events/add-pointer-event.mjs";
+import { extractEventInfo as B } from "../../events/event-info.mjs";
+import { convertBoxToBoundingBox as k, convertBoundingBoxToBox as j } from "../../projection/geometry/conversion.mjs";
+import { calcLength as T } from "../../projection/geometry/delta-calc.mjs";
+import { createBox as w } from "../../projection/geometry/models.mjs";
+import { eachAxis as u } from "../../projection/utils/each-axis.mjs";
+import { measurePageBox as b } from "../../projection/utils/measure.mjs";
+import { getContextWindow as R } from "../../utils/get-context-window.mjs";
+import { isRefObject as D } from "../../utils/is-ref-object.mjs";
+import { addValueToWillChange as V } from "../../value/use-will-change/add-will-change.mjs";
+import { PanSession as W } from "../pan/PanSession.mjs";
+import { applyConstraints as O, calcRelativeConstraints as U, resolveDragElastic as z, calcViewportConstraints as I, defaultElastic as _, rebaseAxisConstraints as F, calcOrigin as K } from "./utils/constraints.mjs";
+import { frame as C } from "../../../../../motion-dom/dist/es/frameloop/frame.mjs";
+import { invariant as N } from "../../../../../motion-utils/dist/es/errors.mjs";
+import { setDragLock as $ } from "../../../../../motion-dom/dist/es/gestures/drag/state/set-active.mjs";
+import { percent as q } from "../../../../../motion-dom/dist/es/value/types/numbers/units.mjs";
+import { mixNumber as x } from "../../../../../motion-dom/dist/es/utils/mix/number.mjs";
+const G = /* @__PURE__ */ new WeakMap();
+class ft {
+  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 = w(), this.visualElement = t;
+  }
+  start(t, { snapToCursor: s = !1 } = {}) {
+    const { presenceContext: n } = this.visualElement;
+    if (n && n.isPresent === !1)
+      return;
+    const i = (r) => {
+      const { dragSnapToOrigin: a } = this.getProps();
+      a ? this.pauseAnimation() : this.stopAnimation(), s && this.snapToCursor(B(r).point);
+    }, o = (r, a) => {
+      const { drag: f, dragPropagation: d, onDragStart: g } = this.getProps();
+      if (f && !d && (this.openDragLock && this.openDragLock(), this.openDragLock = $(f), !this.openDragLock))
+        return;
+      this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), u((m) => {
+        let E = this.getAxisMotionValue(m).get() || 0;
+        if (q.test(E)) {
+          const { projection: A } = this.visualElement;
+          if (A && A.layout) {
+            const y = A.layout.layoutBox[m];
+            y && (E = T(y) * (parseFloat(E) / 100));
+          }
+        }
+        this.originPoint[m] = E;
+      }), g && C.postRender(() => g(r, a)), V(this.visualElement, "transform");
+      const { animationState: v } = this.visualElement;
+      v && v.setActive("whileDrag", !0);
+    }, e = (r, a) => {
+      const { dragPropagation: f, dragDirectionLock: d, onDirectionLock: g, onDrag: v } = this.getProps();
+      if (!f && !this.openDragLock)
+        return;
+      const { offset: m } = a;
+      if (d && this.currentDirection === null) {
+        this.currentDirection = H(m), this.currentDirection !== null && g && g(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", a.point, m), this.updateAxis("y", a.point, m), this.visualElement.render(), v && v(r, a);
+    }, l = (r, a) => this.stop(r, a), c = () => u((r) => {
+      var a;
+      return this.getAnimationState(r) === "paused" && ((a = this.getAxisMotionValue(r).animation) == null ? void 0 : a.play());
+    }), { dragSnapToOrigin: h } = this.getProps();
+    this.panSession = new W(t, {
+      onSessionStart: i,
+      onStart: o,
+      onMove: e,
+      onSessionEnd: l,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: h,
+      contextWindow: R(this.visualElement)
+    });
+  }
+  stop(t, s) {
+    const n = this.isDragging;
+    if (this.cancel(), !n)
+      return;
+    const { velocity: i } = s;
+    this.startAnimation(i);
+    const { onDragEnd: o } = this.getProps();
+    o && C.postRender(() => o(t, s));
+  }
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: s } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.panSession && this.panSession.end(), this.panSession = void 0;
+    const { dragPropagation: n } = this.getProps();
+    !n && this.openDragLock && (this.openDragLock(), this.openDragLock = null), s && s.setActive("whileDrag", !1);
+  }
+  updateAxis(t, s, n) {
+    const { drag: i } = this.getProps();
+    if (!n || !P(t, i, this.currentDirection))
+      return;
+    const o = this.getAxisMotionValue(t);
+    let e = this.originPoint[t] + n[t];
+    this.constraints && this.constraints[t] && (e = O(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 && D(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && n ? this.constraints = U(n.layoutBox, t) : this.constraints = !1, this.elastic = z(s), i !== this.constraints && n && this.constraints && !this.hasMutatedConstraints && u((e) => {
+      this.constraints !== !1 && this.getAxisMotionValue(e) && (this.constraints[e] = F(n.layoutBox[e], this.constraints[e]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: s } = this.getProps();
+    if (!t || !D(t))
+      return !1;
+    const n = t.current;
+    N(n !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.");
+    const { projection: i } = this.visualElement;
+    if (!i || !i.layout)
+      return !1;
+    const o = b(n, i.root, this.visualElement.getTransformPagePoint());
+    let e = I(i.layout.layoutBox, o);
+    if (s) {
+      const l = s(k(e));
+      this.hasMutatedConstraints = !!l, l && (e = j(l));
+    }
+    return e;
+  }
+  startAnimation(t) {
+    const { drag: s, dragMomentum: n, dragElastic: i, dragTransition: o, dragSnapToOrigin: e, onDragTransitionEnd: l } = this.getProps(), c = this.constraints || {}, h = u((r) => {
+      if (!P(r, s, this.currentDirection))
+        return;
+      let a = c && c[r] || {};
+      e && (a = { min: 0, max: 0 });
+      const f = i ? 200 : 1e6, d = i ? 40 : 1e7, g = {
+        type: "inertia",
+        velocity: n ? t[r] : 0,
+        bounceStiffness: f,
+        bounceDamping: d,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...o,
+        ...a
+      };
+      return this.startAxisValueAnimation(r, g);
+    });
+    return Promise.all(h).then(l);
+  }
+  startAxisValueAnimation(t, s) {
+    const n = this.getAxisMotionValue(t);
+    return V(this.visualElement, t), n.start(L(t, n, 0, s, this.visualElement, !1));
+  }
+  stopAnimation() {
+    u((t) => this.getAxisMotionValue(t).stop());
+  }
+  pauseAnimation() {
+    u((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) {
+    u((s) => {
+      const { drag: n } = this.getProps();
+      if (!P(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];
+        o.set(t[s] - x(e, l, 0.5));
+      }
+    });
+  }
+  /**
+   * 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 (!D(s) || !n || !this.constraints)
+      return;
+    this.stopAnimation();
+    const i = { x: 0, y: 0 };
+    u((e) => {
+      const l = this.getAxisMotionValue(e);
+      if (l && this.constraints !== !1) {
+        const c = l.get();
+        i[e] = K({ min: c, max: c }, 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.resolveConstraints(), u((e) => {
+      if (!P(e, t, null))
+        return;
+      const l = this.getAxisMotionValue(e), { min: c, max: h } = this.constraints[e];
+      l.set(x(c, h, i[e]));
+    });
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    G.set(this.visualElement, this);
+    const t = this.visualElement.current, s = S(t, "pointerdown", (c) => {
+      const { drag: h, dragListener: r = !0 } = this.getProps();
+      h && r && this.start(c);
+    }), n = () => {
+      const { dragConstraints: c } = this.getProps();
+      D(c) && c.current && (this.constraints = this.resolveRefConstraints());
+    }, { projection: i } = this.visualElement, o = i.addEventListener("measure", n);
+    i && !i.layout && (i.root && i.root.updateScroll(), i.updateLayout()), C.read(n);
+    const e = M(window, "resize", () => this.scalePositionWithinConstraints()), l = i.addEventListener("didUpdate", ({ delta: c, hasLayoutChanged: h }) => {
+      this.isDragging && h && (u((r) => {
+        const a = this.getAxisMotionValue(r);
+        a && (this.originPoint[r] += c[r].translate, a.set(a.get() + c[r].translate));
+      }), this.visualElement.render());
+    });
+    return () => {
+      e(), s(), o(), l && l();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: s = !1, dragDirectionLock: n = !1, dragPropagation: i = !1, dragConstraints: o = !1, dragElastic: e = _, dragMomentum: l = !0 } = t;
+    return {
+      ...t,
+      drag: s,
+      dragDirectionLock: n,
+      dragPropagation: i,
+      dragConstraints: o,
+      dragElastic: e,
+      dragMomentum: l
+    };
+  }
+}
+function P(p, t, s) {
+  return (t === !0 || t === p) && (s === null || s === p);
+}
+function H(p, t = 10) {
+  let s = null;
+  return Math.abs(p.y) > t ? s = "y" : Math.abs(p.x) > t && (s = "x"), s;
+}
+export {
+  ft as VisualElementDragControls,
+  G as elementDragControls
+};

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

@@ -0,0 +1,18 @@
+import { Feature as s } from "../../motion/features/Feature.mjs";
+import { VisualElementDragControls as t } from "./VisualElementDragControls.mjs";
+import { noop as r } from "../../../../../motion-utils/dist/es/noop.mjs";
+class u extends s {
+  constructor(o) {
+    super(o), this.removeGroupControls = r, this.removeListeners = r, this.controls = new t(o);
+  }
+  mount() {
+    const { dragControls: o } = this.node.getProps();
+    o && (this.removeGroupControls = o.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || r;
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners();
+  }
+}
+export {
+  u as DragGesture
+};

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

@@ -0,0 +1,67 @@
+import { calcLength as r } from "../../../projection/geometry/delta-calc.mjs";
+import { mixNumber as t } from "../../../../../../motion-dom/dist/es/utils/mix/number.mjs";
+import { progress as u } from "../../../../../../motion-utils/dist/es/progress.mjs";
+import { clamp as C } from "../../../../../../motion-utils/dist/es/clamp.mjs";
+function a(n, { min: e, max: m }, i) {
+  return e !== void 0 && n < e ? n = i ? t(e, n, i.min) : Math.max(n, e) : m !== void 0 && n > m && (n = i ? t(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 = r(n), f = r(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/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/gestures/focus.mjs

@@ -0,0 +1,28 @@
+import { addDomEvent as e } from "../events/add-dom-event.mjs";
+import { Feature as i } from "../motion/features/Feature.mjs";
+import { pipe as s } from "../../../../motion-utils/dist/es/pipe.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/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/gestures/hover.mjs

@@ -0,0 +1,21 @@
+import { extractEventInfo as m } from "../events/event-info.mjs";
+import { Feature as s } from "../motion/features/Feature.mjs";
+import { hover as u } from "../../../../motion-dom/dist/es/gestures/hover.mjs";
+import { frame as c } from "../../../../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
+};

package/dist/es/node_modules/.pnpm/motion@12.9.2_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/motion/dist/es/framer-motion/dist/es/gestures/pan/PanSession.mjs

@@ -0,0 +1,84 @@
+import { addPointerEvent as d } from "../../events/add-pointer-event.mjs";
+import { extractEventInfo as w } from "../../events/event-info.mjs";
+import { distance2D as S } from "../../utils/distance.mjs";
+import { frameData as x, frame as D, cancelFrame as T } from "../../../../../motion-dom/dist/es/frameloop/frame.mjs";
+import { isPrimaryPointer as W } from "../../../../../motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs";
+import { pipe as L } from "../../../../../motion-utils/dist/es/pipe.mjs";
+import { secondsToMilliseconds as U, millisecondsToSeconds as O } from "../../../../../motion-utils/dist/es/time-conversion.mjs";
+class B {
+  constructor(n, o, { transformPagePoint: e, contextWindow: r, dragSnapToOrigin: h = !1 } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const i = p(this.lastMoveEventInfo, this.history), a = this.startEvent !== null, c = S(i.offset, { x: 0, y: 0 }) >= 3;
+      if (!a && !c)
+        return;
+      const { point: f } = i, { timestamp: m } = x;
+      this.history.push({ ...f, timestamp: m });
+      const { onStart: l, onMove: E } = this.handlers;
+      a || (l && l(this.lastMoveEvent, i), this.startEvent = this.lastMoveEvent), E && E(this.lastMoveEvent, i);
+    }, this.handlePointerMove = (i, a) => {
+      this.lastMoveEvent = i, this.lastMoveEventInfo = v(a, this.transformPagePoint), D.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (i, a) => {
+      this.end();
+      const { onEnd: c, onSessionEnd: f, resumeAnimation: m } = this.handlers;
+      if (this.dragSnapToOrigin && m && m(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const l = p(i.type === "pointercancel" ? this.lastMoveEventInfo : v(a, this.transformPagePoint), this.history);
+      this.startEvent && c && c(i, l), f && f(i, l);
+    }, !W(n))
+      return;
+    this.dragSnapToOrigin = h, this.handlers = o, this.transformPagePoint = e, this.contextWindow = r || window;
+    const s = w(n), u = v(s, this.transformPagePoint), { point: g } = u, { timestamp: I } = x;
+    this.history = [{ ...g, timestamp: I }];
+    const { onSessionStart: P } = o;
+    P && P(n, p(u, this.history)), this.removeListeners = L(d(this.contextWindow, "pointermove", this.handlePointerMove), d(this.contextWindow, "pointerup", this.handlePointerUp), d(this.contextWindow, "pointercancel", this.handlePointerUp));
+  }
+  updateHandlers(n) {
+    this.handlers = n;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), T(this.updatePoint);
+  }
+}
+function v(t, n) {
+  return n ? { point: n(t.point) } : t;
+}
+function y(t, n) {
+  return { x: t.x - n.x, y: t.y - n.y };
+}
+function p({ point: t }, n) {
+  return {
+    point: t,
+    delta: y(t, M(n)),
+    offset: y(t, V(n)),
+    velocity: b(n, 0.1)
+  };
+}
+function V(t) {
+  return t[0];
+}
+function M(t) {
+  return t[t.length - 1];
+}
+function b(t, n) {
+  if (t.length < 2)
+    return { x: 0, y: 0 };
+  let o = t.length - 1, e = null;
+  const r = M(t);
+  for (; o >= 0 && (e = t[o], !(r.timestamp - e.timestamp > U(n))); )
+    o--;
+  if (!e)
+    return { x: 0, y: 0 };
+  const h = O(r.timestamp - e.timestamp);
+  if (h === 0)
+    return { x: 0, y: 0 };
+  const s = {
+    x: (r.x - e.x) / h,
+    y: (r.y - e.y) / h
+  };
+  return s.x === 1 / 0 && (s.x = 0), s.y === 1 / 0 && (s.y = 0), s;
+}
+export {
+  B as PanSession
+};

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

@@ -0,0 +1,43 @@
+import { addPointerEvent as m } from "../../events/add-pointer-event.mjs";
+import { Feature as P } from "../../motion/features/Feature.mjs";
+import { getContextWindow as h } from "../../utils/get-context-window.mjs";
+import { PanSession as p } from "./PanSession.mjs";
+import { noop as u } from "../../../../../motion-utils/dist/es/noop.mjs";
+import { frame as r } from "../../../../../motion-dom/dist/es/frameloop/frame.mjs";
+const s = (e) => (n, o) => {
+  e && r.postRender(() => e(n, o));
+};
+class v extends P {
+  constructor() {
+    super(...arguments), this.removePointerDownListener = u;
+  }
+  onPointerDown(n) {
+    this.session = new p(n, this.createPanHandlers(), {
+      transformPagePoint: this.node.getTransformPagePoint(),
+      contextWindow: h(this.node)
+    });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart: n, onPanStart: o, onPan: i, onPanEnd: t } = this.node.getProps();
+    return {
+      onSessionStart: s(n),
+      onStart: s(o),
+      onMove: i,
+      onEnd: (a, d) => {
+        delete this.session, t && r.postRender(() => t(a, d));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = m(this.node.current, "pointerdown", (n) => this.onPointerDown(n));
+  }
+  update() {
+    this.session && this.session.updateHandlers(this.createPanHandlers());
+  }
+  unmount() {
+    this.removePointerDownListener(), this.session && this.session.end();
+  }
+}
+export {
+  v as PanGesture
+};

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

@@ -0,0 +1,23 @@
+import { extractEventInfo as i } from "../events/event-info.mjs";
+import { Feature as m } from "../motion/features/Feature.mjs";
+import { press as u } from "../../../../motion-dom/dist/es/gestures/press/index.mjs";
+import { frame as p } from "../../../../motion-dom/dist/es/frameloop/frame.mjs";
+function s(t, e, n) {
+  const { props: r } = t;
+  if (t.current instanceof HTMLButtonElement && t.current.disabled)
+    return;
+  t.animationState && r.whileTap && t.animationState.setActive("whileTap", n === "Start");
+  const a = "onTap" + (n === "End" ? "" : n), o = r[a];
+  o && p.postRender(() => o(e, i(e)));
+}
+class d extends m {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = u(e, (n, r) => (s(this.node, r, "Start"), (a, { success: o }) => s(this.node, a, o ? "End" : "Cancel")), { useGlobalTarget: this.node.props.globalTapTarget }));
+  }
+  unmount() {
+  }
+}
+export {
+  d as PressGesture
+};

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

@@ -0,0 +1,10 @@
+class s {
+  constructor(t) {
+    this.isMounted = !1, this.node = t;
+  }
+  update() {
+  }
+}
+export {
+  s as Feature
+};

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

@@ -0,0 +1,27 @@
+import { Feature as s } from "../Feature.mjs";
+let o = 0;
+class d extends s {
+  constructor() {
+    super(...arguments), this.id = o++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: t, onExitComplete: e } = this.node.presenceContext, { isPresent: n } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || t === n)
+      return;
+    const i = this.node.animationState.setActive("exit", !t);
+    e && !t && i.then(() => {
+      e(this.id);
+    });
+  }
+  mount() {
+    const { register: t, onExitComplete: e } = this.node.presenceContext || {};
+    e && e(this.id), t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}
+export {
+  d as ExitAnimationFeature
+};

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

@@ -0,0 +1,34 @@
+import { isAnimationControls as o } from "../../../animation/utils/is-animation-controls.mjs";
+import { createAnimationState as i } from "../../../render/utils/animation-state.mjs";
+import { Feature as s } from "../Feature.mjs";
+class u extends s {
+  /**
+   * We dynamically generate the AnimationState manager as it contains a reference
+   * to the underlying animation library. We only want to load that if we load this,
+   * so people can optionally code split it out using the `m` component.
+   */
+  constructor(t) {
+    super(t), t.animationState || (t.animationState = i(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    o(t) && (this.unmountControls = t.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    t !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    var t;
+    this.node.animationState.reset(), (t = this.unmountControls) == null || t.call(this);
+  }
+}
+export {
+  u as AnimationFeature
+};

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

@@ -0,0 +1,13 @@
+import { AnimationFeature as t } from "./animation/index.mjs";
+import { ExitAnimationFeature as i } from "./animation/exit.mjs";
+const o = {
+  animation: {
+    Feature: t
+  },
+  exit: {
+    Feature: i
+  }
+};
+export {
+  o as animations
+};

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

@@ -0,0 +1,27 @@
+const n = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, t = {};
+for (const e in n)
+  t[e] = {
+    isEnabled: (o) => n[e].some((a) => !!o[a])
+  };
+export {
+  t as featureDefinitions
+};