@vkzstudio/muza-ui 1.0.0 → 1.0.2

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-dom-keyframes.js

@@ -0,0 +1,6 @@
+function t(r) {
+  return typeof r == "object" && !Array.isArray(r);
+}
+export {
+  t as isDOMKeyframes
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.js

@@ -0,0 +1,4 @@
+const e = (r) => Array.isArray(r);
+export {
+  e as isKeyframesTarget
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-transition-defined.js

@@ -0,0 +1,6 @@
+function g({ when: r, delay: t, delayChildren: a, staggerChildren: n, staggerDirection: i, repeat: l, repeatType: d, repeatDelay: p, from: s, elapsed: y, ...e }) {
+  return !!Object.keys(e).length;
+}
+export {
+  g as isTransitionDefined
+};

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.js

@@ -0,0 +1,57 @@
+import { jsx as R } from "react/jsx-runtime";
+import * as a from "react";
+import { useId as $, useRef as d, useContext as w, useInsertionEffect as P } from "react";
+import { MotionConfigContext as z } from "../../context/MotionConfigContext.js";
+import { useComposedRefs as E } from "../../utils/use-composed-ref.js";
+import { isHTMLElement as I } from "../../../../../motion-dom/dist/es/utils/is-html-element.js";
+class M extends a.Component {
+  getSnapshotBeforeUpdate(i) {
+    const e = this.props.childRef.current;
+    if (e && i.isPresent && !this.props.isPresent) {
+      const r = e.offsetParent, s = I(r) && r.offsetWidth || 0, t = this.props.sizeRef.current;
+      t.height = e.offsetHeight || 0, t.width = e.offsetWidth || 0, t.top = e.offsetTop, t.left = e.offsetLeft, t.right = s - t.width - t.left;
+    }
+    return null;
+  }
+  /**
+   * Required with getSnapshotBeforeUpdate to stop React complaining.
+   */
+  componentDidUpdate() {
+  }
+  render() {
+    return this.props.children;
+  }
+}
+function U({ children: n, isPresent: i, anchorX: e, root: r }) {
+  const s = $(), t = d(null), f = d({
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    right: 0
+  }), { nonce: h } = w(z), l = E(t, n == null ? void 0 : n.ref);
+  return P(() => {
+    const { width: c, height: m, top: u, left: g, right: x } = f.current;
+    if (i || !t.current || !c || !m)
+      return;
+    const C = e === "left" ? `left: ${g}` : `right: ${x}`;
+    t.current.dataset.motionPopId = s;
+    const o = document.createElement("style");
+    h && (o.nonce = h);
+    const p = r ?? document.head;
+    return p.appendChild(o), o.sheet && o.sheet.insertRule(`
+          [data-motion-pop-id="${s}"] {
+            position: absolute !important;
+            width: ${c}px !important;
+            height: ${m}px !important;
+            ${C}px !important;
+            top: ${u}px !important;
+          }
+        `), () => {
+      p.contains(o) && p.removeChild(o);
+    };
+  }, [i]), R(M, { isPresent: i, childRef: t, sizeRef: f, children: a.cloneElement(n, { ref: l }) });
+}
+export {
+  U as PopChild
+};

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.js

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

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/index.js

@@ -0,0 +1,45 @@
+import { jsx as E, Fragment as N } from "react/jsx-runtime";
+import { useMemo as F, useRef as w, useState as k, useContext as G } from "react";
+import { LayoutGroupContext as O } from "../../context/LayoutGroupContext.js";
+import { useConstant as R } from "../../utils/use-constant.js";
+import { useIsomorphicLayoutEffect as S } from "../../utils/use-isomorphic-effect.js";
+import { PresenceChild as V } from "./PresenceChild.js";
+import { usePresence as X } from "./use-presence.js";
+import { onlyElements as v, getChildKey as c } from "./utils.js";
+const T = ({ children: h, custom: A, initial: L = !0, onExitComplete: p, presenceAffectsLayout: b = !0, mode: u = "sync", propagate: l = !1, anchorX: j = "left", root: D }) => {
+  const [C, f] = X(l), n = F(() => v(h), [h]), o = l && !C ? [] : n.map(c), y = w(!0), x = w(n), r = R(() => /* @__PURE__ */ new Map()), [I, K] = k(n), [i, P] = k(n);
+  S(() => {
+    y.current = !1, x.current = n;
+    for (let t = 0; t < i.length; t++) {
+      const e = c(i[t]);
+      o.includes(e) ? r.delete(e) : r.get(e) !== !0 && r.set(e, !1);
+    }
+  }, [i, o.length, o.join("-")]);
+  const d = [];
+  if (n !== I) {
+    let t = [...n];
+    for (let e = 0; e < i.length; e++) {
+      const s = i[e], a = c(s);
+      o.includes(a) || (t.splice(e, 0, s), d.push(s));
+    }
+    return u === "wait" && d.length && (t = d), P(v(t)), K(n), null;
+  }
+  process.env.NODE_ENV !== "production" && u === "wait" && i.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: m } = G(O);
+  return E(N, { children: i.map((t) => {
+    const e = c(t), s = l && !C ? !1 : n === i || o.includes(e), a = () => {
+      if (r.has(e))
+        r.set(e, !0);
+      else
+        return;
+      let g = !0;
+      r.forEach((M) => {
+        M || (g = !1);
+      }), g && (m == null || m(), P(x.current), l && (f == null || f()), p && p());
+    };
+    return E(V, { isPresent: s, initial: !y.current || L ? void 0 : !1, custom: A, presenceAffectsLayout: b, mode: u, root: D, onExitComplete: s ? void 0 : a, anchorX: j, children: t }, e);
+  }) });
+};
+export {
+  T as AnimatePresence
+};

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.js

@@ -0,0 +1,17 @@
+import { useContext as f, useId as l, useEffect as c, useCallback as i } from "react";
+import { PresenceContext as m } from "../../context/PresenceContext.js";
+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/node_modules/framer-motion/dist/es/components/AnimatePresence/utils.js

@@ -0,0 +1,12 @@
+import { Children as o, isValidElement as r } from "react";
+const l = (e) => e.key || "";
+function f(e) {
+  const t = [];
+  return o.forEach(e, (n) => {
+    r(n) && t.push(n);
+  }), t;
+}
+export {
+  l as getChildKey,
+  f as onlyElements
+};

package/dist/node_modules/framer-motion/dist/es/context/LayoutGroupContext.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = t({});
+export {
+  e as LayoutGroupContext
+};

package/dist/node_modules/framer-motion/dist/es/context/LazyContext.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const o = t({ strict: !1 });
+export {
+  o as LazyContext
+};

package/dist/node_modules/framer-motion/dist/es/context/MotionConfigContext.js

@@ -0,0 +1,9 @@
+import { createContext as o } from "react";
+const n = o({
+  transformPagePoint: (t) => t,
+  isStatic: !1,
+  reducedMotion: "never"
+});
+export {
+  n as MotionConfigContext
+};

package/dist/node_modules/framer-motion/dist/es/context/MotionContext/create.js

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

package/dist/node_modules/framer-motion/dist/es/context/MotionContext/index.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = /* @__PURE__ */ t({});
+export {
+  e as MotionContext
+};

package/dist/node_modules/framer-motion/dist/es/context/MotionContext/utils.js

@@ -0,0 +1,15 @@
+import { isControllingVariants as r } from "../../render/utils/is-controlling-variants.js";
+import { isVariantLabel as e } from "../../render/utils/is-variant-label.js";
+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/node_modules/framer-motion/dist/es/context/PresenceContext.js

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+const o = /* @__PURE__ */ e(null);
+export {
+  o as PresenceContext
+};

package/dist/node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = t({});
+export {
+  e as SwitchLayoutGroupContext
+};

package/dist/node_modules/framer-motion/dist/es/events/add-dom-event.js

@@ -0,0 +1,6 @@
+function i(e, n, t, r = { passive: !0 }) {
+  return e.addEventListener(n, t, r), () => e.removeEventListener(n, t);
+}
+export {
+  i as addDomEvent
+};

package/dist/node_modules/framer-motion/dist/es/events/add-pointer-event.js

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

package/dist/node_modules/framer-motion/dist/es/events/event-info.js

@@ -0,0 +1,14 @@
+import { isPrimaryPointer as t } from "../../../../motion-dom/dist/es/gestures/utils/is-primary-pointer.js";
+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/node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.js

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

package/dist/node_modules/framer-motion/dist/es/gestures/drag/index.js

@@ -0,0 +1,18 @@
+import { Feature as s } from "../../motion/features/Feature.js";
+import { VisualElementDragControls as t } from "./VisualElementDragControls.js";
+import { noop as r } from "../../../../../motion-utils/dist/es/noop.js";
+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/node_modules/framer-motion/dist/es/gestures/drag/use-drag-controls.js

@@ -0,0 +1,70 @@
+import { useConstant as r } from "../../utils/use-constant.js";
+class s {
+  constructor() {
+    this.componentControls = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Subscribe a component's internal `VisualElementDragControls` to the user-facing API.
+   *
+   * @internal
+   */
+  subscribe(o) {
+    return this.componentControls.add(o), () => this.componentControls.delete(o);
+  }
+  /**
+   * Start a drag gesture on every `motion` component that has this set of drag controls
+   * passed into it via the `dragControls` prop.
+   *
+   * ```jsx
+   * dragControls.start(e, {
+   *   snapToCursor: true
+   * })
+   * ```
+   *
+   * @param event - PointerEvent
+   * @param options - Options
+   *
+   * @public
+   */
+  start(o, t) {
+    this.componentControls.forEach((n) => {
+      n.start(o.nativeEvent || o, t);
+    });
+  }
+  /**
+   * Cancels a drag gesture.
+   *
+   * ```jsx
+   * dragControls.cancel()
+   * ```
+   *
+   * @public
+   */
+  cancel() {
+    this.componentControls.forEach((o) => {
+      o.cancel();
+    });
+  }
+  /**
+   * Stops a drag gesture.
+   *
+   * ```jsx
+   * dragControls.stop()
+   * ```
+   *
+   * @public
+   */
+  stop() {
+    this.componentControls.forEach((o) => {
+      o.stop();
+    });
+  }
+}
+const e = () => new s();
+function l() {
+  return r(e);
+}
+export {
+  s as DragControls,
+  l as useDragControls
+};