@quoreadmin/ui 1.7.7 → 1.7.9

package/dist/index171.js

@@ -1,1310 +1,774 @@
-import st from "./index202.js";
-import { reactive as V, watch as h, ref as g, defineComponent as Z, useSlots as H, h as K, Fragment as at, inject as ct, computed as A, toRaw as lt, unref as x } from "vue";
-import { unrefElement as ut, useIntersectionObserver as ft, useEventListener as m } from "./index203.js";
-import { tryOnUnmounted as pt, isObject as yt } from "./index204.js";
-import D, { getFrameData as dt } from "./index205.js";
-import { complex as $ } from "./index206.js";
-import { number as mt, alpha as C, scale as j } from "./index207.js";
-import { filter as P } from "./index208.js";
-import { px as c, progressPercentage as F, degrees as O } from "./index209.js";
-import { color as b } from "./index210.js";
-import { inertia as bt } from "./index211.js";
-import { animate as ht } from "./index212.js";
-import { velocityPerSecond as vt } from "./index213.js";
-import { cubicBezier as gt } from "./index214.js";
-import { bounceOut as Ot, bounceInOut as Tt, bounceIn as At, anticipate as xt, backOut as jt, backInOut as Vt, backIn as St, circOut as Ct, circInOut as Et, circIn as Nt, easeOut as Pt, easeInOut as _t, easeIn as wt, linear as Rt } from "./index215.js";
-const R = {};
-class Mt {
-  subscriptions = /* @__PURE__ */ new Set();
-  add(e) {
-    return this.subscriptions.add(e), () => this.subscriptions.delete(e);
-  }
-  notify(e, i, r) {
-    if (this.subscriptions.size)
-      for (const n of this.subscriptions) n(e, i, r);
-  }
-  clear() {
-    this.subscriptions.clear();
+import { ref as Z, getCurrentInstance as tt, onMounted as et, onUnmounted as st, unref as w, nextTick as nt } from "vue";
+function rt() {
+  try {
+    return "constructor" in GestureEvent;
+  } catch {
+    return !1;
   }
 }
-function z(t) {
-  return !Number.isNaN(Number.parseFloat(t));
+function j() {
+  return typeof window < "u" && "ontouchstart" in window;
 }
-class Lt {
-  /**
-   * The current state of the `MotionValue`.
-   */
-  current;
-  /**
-   * The previous state of the `MotionValue`.
-   */
-  prev;
-  /**
-   * Duration, in milliseconds, since last updating frame.
-   */
-  timeDelta = 0;
-  /**
-   * Timestamp of the last time this `MotionValue` was updated.
-   */
-  lastUpdated = 0;
-  /**
-   * Functions to notify when the `MotionValue` updates.
-   */
-  updateSubscribers = new Mt();
-  /**
-   * A reference to the currently-controlling Popmotion animation
-   */
-  stopAnimation;
-  /**
-   * Tracks whether this value can output a velocity.
-   */
-  canTrackVelocity = !1;
-  /**
-   * init - The initiating value
-   * config - Optional configuration options
-   */
-  constructor(e) {
-    this.prev = this.current = e, this.canTrackVelocity = z(this.current);
-  }
-  /**
-   * Adds a function that will be notified when the `MotionValue` is updated.
-   *
-   * It returns a function that, when called, will cancel the subscription.
-   */
-  onChange(e) {
-    return this.updateSubscribers.add(e);
-  }
-  clearListeners() {
-    this.updateSubscribers.clear();
-  }
-  /**
-   * Sets the state of the `MotionValue`.
-   *
-   * @param v
-   * @param render
-   */
-  set(e) {
-    this.updateAndNotify(e);
-  }
-  /**
-   * Update and notify `MotionValue` subscribers.
-   *
-   * @param v
-   * @param render
-   */
-  updateAndNotify = (e) => {
-    this.prev = this.current, this.current = e;
-    const { delta: i, timestamp: r } = dt();
-    this.lastUpdated !== r && (this.timeDelta = i, this.lastUpdated = r), D.postRender(this.scheduleVelocityCheck), this.updateSubscribers.notify(this.current);
-  };
-  /**
-   * Returns the latest state of `MotionValue`
-   *
-   * @returns - The latest state of `MotionValue`
-   */
-  get() {
-    return this.current;
-  }
-  /**
-   * Get previous value.
-   *
-   * @returns - The previous latest state of `MotionValue`
-   */
-  getPrevious() {
-    return this.prev;
-  }
-  /**
-   * Returns the latest velocity of `MotionValue`
-   *
-   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
-   */
-  getVelocity() {
-    return this.canTrackVelocity ? vt(Number.parseFloat(this.current) - Number.parseFloat(this.prev), this.timeDelta) : 0;
-  }
-  /**
-   * Schedule a velocity check for the next frame.
-   */
-  scheduleVelocityCheck = () => D.postRender(this.velocityCheck);
-  /**
-   * Updates `prev` with `current` if the value hasn't been updated this frame.
-   * This ensures velocity calculations return `0`.
-   */
-  velocityCheck = ({ timestamp: e }) => {
-    this.canTrackVelocity || (this.canTrackVelocity = z(this.current)), e !== this.lastUpdated && (this.prev = this.current);
-  };
-  /**
-   * Registers a new animation to control this `MotionValue`. Only one
-   * animation can drive a `MotionValue` at one time.
-   */
-  start(e) {
-    return this.stop(), new Promise((i) => {
-      const { stop: r } = e(i);
-      this.stopAnimation = r;
-    }).then(() => this.clearAnimation());
-  }
-  /**
-   * Stop the currently active animation.
-   */
-  stop() {
-    this.stopAnimation && this.stopAnimation(), this.clearAnimation();
-  }
-  /**
-   * Returns `true` if this value is currently animating.
-   */
-  isAnimating() {
-    return !!this.stopAnimation;
-  }
-  /**
-   * Clear the current animation reference.
-   */
-  clearAnimation() {
-    this.stopAnimation = null;
-  }
-  /**
-   * Destroy and clean up subscribers to this `MotionValue`.
-   */
-  destroy() {
-    this.updateSubscribers.clear(), this.stop();
-  }
+function V(e) {
+  return "pointerId" in e ? null : e.type === "touchend" ? e.changedTouches : e.targetTouches;
 }
-function kt(t) {
-  return new Lt(t);
+function Y(e) {
+  return Array.from(V(e)).map((t) => t.identifier);
 }
-const { isArray: qt } = Array;
-function Bt() {
-  const t = g({}), e = (r) => {
-    const n = (o) => {
-      t.value[o] && (t.value[o].stop(), t.value[o].destroy(), delete t.value[o]);
-    };
-    r ? qt(r) ? r.forEach(n) : n(r) : Object.keys(t.value).forEach(n);
-  }, i = (r, n, o) => {
-    if (t.value[r])
-      return t.value[r];
-    const s = kt(n);
-    return s.onChange((a) => o[r] = a), t.value[r] = s, s;
-  };
-  return pt(e), {
-    motionValues: t,
-    get: i,
-    stop: e
-  };
+function L(e) {
+  const t = "buttons" in e ? e.buttons : 0, { shiftKey: s, altKey: n, metaKey: r, ctrlKey: i } = e;
+  return { buttons: t, shiftKey: s, altKey: n, metaKey: r, ctrlKey: i };
 }
-function Dt(t) {
-  return Array.isArray(t);
+const it = (e) => e;
+function G(e, t = it) {
+  const s = V(e), { clientX: n, clientY: r } = s ? s[0] : e;
+  return t([n, r]);
 }
-function T() {
-  return {
-    type: "spring",
-    stiffness: 500,
-    damping: 25,
-    restDelta: 0.5,
-    restSpeed: 10
-  };
+function $() {
 }
-function E(t) {
-  return {
-    type: "spring",
-    stiffness: 550,
-    damping: t === 0 ? 2 * Math.sqrt(550) : 30,
-    restDelta: 0.01,
-    restSpeed: 10
+function F(...e) {
+  return e.length === 0 ? $ : e.length === 1 ? e[0] : function() {
+    var t;
+    for (let s of e)
+      t = s.apply(this, arguments) || t;
+    return t;
   };
 }
-function Ft(t) {
-  return {
-    type: "spring",
-    stiffness: 550,
-    damping: t === 0 ? 100 : 30,
-    restDelta: 0.01,
-    restSpeed: 10
-  };
+function g(e, t) {
+  if (e === void 0) {
+    if (t === void 0)
+      throw new Error("Must define fallback value if undefined is expected");
+    e = t;
+  }
+  return Array.isArray(e) ? e : [e, e];
 }
-function N() {
-  return {
-    type: "keyframes",
-    ease: "linear",
-    duration: 300
-  };
+function K(e, ...t) {
+  return typeof e == "function" ? e(...t) : e;
 }
-function zt(t) {
+function _(e) {
   return {
-    type: "keyframes",
-    duration: 800,
-    values: t
+    _active: !1,
+    _blocked: !1,
+    _intentional: [!1, !1],
+    _movement: [0, 0],
+    _initial: [0, 0],
+    _bounds: [
+      [-1 / 0, 1 / 0],
+      [-1 / 0, 1 / 0]
+    ],
+    _lastEventType: void 0,
+    _dragStarted: !1,
+    _dragPreventScroll: !1,
+    _dragIsTap: !0,
+    _dragDelayed: !1,
+    event: void 0,
+    intentional: !1,
+    values: [0, 0],
+    velocities: [0, 0],
+    delta: [0, 0],
+    movement: [0, 0],
+    offset: [0, 0],
+    lastOffset: [0, 0],
+    direction: [0, 0],
+    initial: [0, 0],
+    previous: [0, 0],
+    first: !1,
+    last: !1,
+    active: !1,
+    timeStamp: 0,
+    startTime: 0,
+    elapsedTime: 0,
+    cancel: $,
+    canceled: !1,
+    memo: void 0,
+    args: void 0,
+    ...e
   };
 }
-const I = {
-  default: Ft,
-  x: T,
-  y: T,
-  z: T,
-  rotate: T,
-  rotateX: T,
-  rotateY: T,
-  rotateZ: T,
-  scaleX: E,
-  scaleY: E,
-  scale: E,
-  backgroundColor: N,
-  color: N,
-  opacity: N
-};
-function G(t, e) {
-  let i;
-  return Dt(e) ? i = zt : i = I[t] || I.default, { to: e, ...i(e) };
-}
-const U = {
-  ...mt,
-  transform: Math.round
-}, J = {
-  // Color props
-  color: b,
-  backgroundColor: b,
-  outlineColor: b,
-  fill: b,
-  stroke: b,
-  // Border props
-  borderColor: b,
-  borderTopColor: b,
-  borderRightColor: b,
-  borderBottomColor: b,
-  borderLeftColor: b,
-  borderWidth: c,
-  borderTopWidth: c,
-  borderRightWidth: c,
-  borderBottomWidth: c,
-  borderLeftWidth: c,
-  borderRadius: c,
-  radius: c,
-  borderTopLeftRadius: c,
-  borderTopRightRadius: c,
-  borderBottomRightRadius: c,
-  borderBottomLeftRadius: c,
-  // Positioning props
-  width: c,
-  maxWidth: c,
-  height: c,
-  maxHeight: c,
-  size: c,
-  top: c,
-  right: c,
-  bottom: c,
-  left: c,
-  // Spacing props
-  padding: c,
-  paddingTop: c,
-  paddingRight: c,
-  paddingBottom: c,
-  paddingLeft: c,
-  margin: c,
-  marginTop: c,
-  marginRight: c,
-  marginBottom: c,
-  marginLeft: c,
-  // Transform props
-  rotate: O,
-  rotateX: O,
-  rotateY: O,
-  rotateZ: O,
-  scale: j,
-  scaleX: j,
-  scaleY: j,
-  scaleZ: j,
-  skew: O,
-  skewX: O,
-  skewY: O,
-  distance: c,
-  translateX: c,
-  translateY: c,
-  translateZ: c,
-  x: c,
-  y: c,
-  z: c,
-  perspective: c,
-  transformPerspective: c,
-  opacity: C,
-  originX: F,
-  originY: F,
-  originZ: c,
-  // Misc
-  zIndex: U,
-  filter: P,
-  WebkitFilter: P,
-  // SVG
-  fillOpacity: C,
-  strokeOpacity: C,
-  numOctaves: U
-}, M = (t) => J[t];
-function _(t, e) {
-  return e && typeof t == "number" && e.transform ? e.transform(t) : t;
+function P() {
+  const e = {
+    hovering: !1,
+    scrolling: !1,
+    wheeling: !1,
+    dragging: !1,
+    moving: !1,
+    pinching: !1,
+    touches: 0,
+    buttons: 0,
+    down: !1,
+    shiftKey: !1,
+    altKey: !1,
+    metaKey: !1,
+    ctrlKey: !1,
+    locked: !1
+  }, t = _({
+    _pointerId: void 0,
+    axis: void 0,
+    xy: [0, 0],
+    vxvy: [0, 0],
+    velocity: 0,
+    distance: 0,
+    tap: !1,
+    swipe: [0, 0]
+  }), s = _({
+    // @ts-expect-error when used _pointerIds we can assert its type will be [number, number]
+    _pointerIds: [],
+    da: [0, 0],
+    vdva: [0, 0],
+    // @ts-expect-error origin can never be passed as undefined in userland
+    origin: void 0,
+    turns: 0
+  }), n = _({
+    axis: void 0,
+    xy: [0, 0],
+    vxvy: [0, 0],
+    velocity: 0,
+    distance: 0
+  }), r = _({
+    axis: void 0,
+    xy: [0, 0],
+    vxvy: [0, 0],
+    velocity: 0,
+    distance: 0
+  }), i = _({
+    axis: void 0,
+    xy: [0, 0],
+    vxvy: [0, 0],
+    velocity: 0,
+    distance: 0
+  });
+  return { shared: e, drag: t, pinch: s, wheel: n, move: r, scroll: i };
+}
+var ot = Object.defineProperty, at = (e, t, s) => t in e ? ot(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, h = (e, t, s) => (at(e, typeof t != "symbol" ? t + "" : t, s), s);
+class ct {
+  constructor(t) {
+    this.classes = t, h(this, "nativeRefs"), h(this, "config"), h(this, "handlers"), h(this, "state"), h(this, "timeouts"), h(this, "domListeners"), h(this, "windowListeners"), h(this, "pointerIds", /* @__PURE__ */ new Set()), h(this, "touchIds", /* @__PURE__ */ new Set()), h(this, "supportsTouchEvents", j()), h(this, "supportsGestureEvents", rt()), h(this, "bind", (...s) => {
+      const n = {};
+      for (let r of this.classes)
+        new r(this, s).addBindings(n);
+      for (let r in this.nativeRefs)
+        p(
+          n,
+          r,
+          (i) => this.nativeRefs[r]({ ...this.state.shared, event: i, args: s })
+        );
+      return this.config.domTarget ? pt(this, n) : gt(this, n);
+    }), h(this, "clean", () => {
+      const { eventOptions: s, domTarget: n } = this.config, r = w(n);
+      r && b(r, B(this.domListeners), s), Object.values(this.timeouts).forEach(clearTimeout), ft(this);
+    }), h(this, "reset", () => {
+      this.state = P();
+    }), this.classes = t, this.state = P(), this.timeouts = {}, this.domListeners = [], this.windowListeners = {};
+  }
+}
+function lt(e, t) {
+  "pointerId" in t ? e.pointerIds.add(t.pointerId) : e.touchIds = new Set(Y(t));
+}
+function ut(e, t) {
+  "pointerId" in t ? e.pointerIds.delete(t.pointerId) : Y(t).forEach((s) => e.touchIds.delete(s));
+}
+function ft(e) {
+  const {
+    config: { window: t, eventOptions: s },
+    windowListeners: n
+  } = e, r = w(t);
+  if (r) {
+    for (let i in n) {
+      const a = n[i];
+      b(r, a, s);
+    }
+    e.windowListeners = {};
+  }
 }
-function It(t, e) {
-  let i = M(t);
-  return i !== P && (i = $), i.getAnimatableNone ? i.getAnimatableNone(e) : void 0;
+function ht({ config: e, windowListeners: t }, s, n = e.eventOptions) {
+  const r = w(e.window);
+  r && (b(r, t[s], n), delete t[s]);
 }
-const Ut = {
-  linear: Rt,
-  easeIn: wt,
-  easeInOut: _t,
-  easeOut: Pt,
-  circIn: Nt,
-  circInOut: Et,
-  circOut: Ct,
-  backIn: St,
-  backInOut: Vt,
-  backOut: jt,
-  anticipate: xt,
-  bounceIn: At,
-  bounceInOut: Tt,
-  bounceOut: Ot
-};
-function W(t) {
-  if (Array.isArray(t)) {
-    const [e, i, r, n] = t;
-    return gt(e, i, r, n);
-  } else if (typeof t == "string")
-    return Ut[t];
-  return t;
+function dt({ config: e, windowListeners: t }, s, n = [], r = e.eventOptions) {
+  const i = w(e.window);
+  i && (b(i, t[s], r), X(i, t[s] = n, r));
 }
-function Wt(t) {
-  return Array.isArray(t) && typeof t[0] != "number";
+function pt({ config: e, domListeners: t }, s) {
+  const { eventOptions: n, domTarget: r } = e, i = w(r);
+  if (!i)
+    throw new Error("domTarget must be defined");
+  b(i, B(t), n);
+  for (let [a, o] of Object.entries(s)) {
+    const u = a.slice(2).toLowerCase();
+    t.push([u, F(...o)]);
+  }
+  X(i, t, n);
 }
-function X(t, e) {
-  return t === "zIndex" ? !1 : !!(typeof e == "number" || Array.isArray(e) || typeof e == "string" && $.test(e) && !e.startsWith("url("));
+function gt({ config: e }, t) {
+  const s = {}, n = e.eventOptions.capture ? "Capture" : "";
+  for (let [r, i] of Object.entries(t)) {
+    const a = Array.isArray(i) ? i : [i], o = r + n;
+    s[o] = F(...a);
+  }
+  return s;
 }
-function Xt(t) {
-  return Array.isArray(t.to) && t.to[0] === null && (t.to = [...t.to], t.to[0] = t.from), t;
+function B(e = []) {
+  return e.splice(0, e.length);
 }
-function Yt({ ease: t, times: e, delay: i, ...r }) {
-  const n = { ...r };
-  return e && (n.offset = e), t && (n.ease = Wt(t) ? t.map(W) : W(t)), i && (n.elapsed = -i), n;
+function p(e, t, s) {
+  e[t] || (e[t] = []), e[t].push(s);
 }
-function Zt(t, e, i) {
-  return Array.isArray(e.to) && (t.duration || (t.duration = 800)), Xt(e), Ht(t) || (t = {
-    ...t,
-    ...G(i, e.to)
-  }), {
-    ...e,
-    ...Yt(t)
-  };
+function X(e, t = [], s = {}) {
+  if (e)
+    for (let [n, r] of t)
+      e.addEventListener(n, r, s);
 }
-function Ht({ delay: t, repeat: e, repeatType: i, repeatDelay: r, from: n, ...o }) {
-  return !!Object.keys(o).length;
+function b(e, t = [], s = {}) {
+  if (e)
+    for (let [n, r] of t)
+      e.removeEventListener(n, r, s);
 }
-function Kt(t, e) {
-  return t[e] || t.default || t;
+function x(e, t) {
+  return e.map((s, n) => s + t[n]);
 }
-function $t(t, e, i, r, n) {
-  const o = Kt(r, t);
-  let s = o.from === null || o.from === void 0 ? e.get() : o.from;
-  const a = X(t, i);
-  s === "none" && a && typeof i == "string" && (s = It(t, i));
-  const l = X(t, s);
-  function p(f) {
-    const y = {
-      from: s,
-      to: i,
-      velocity: r.velocity ? r.velocity : e.getVelocity(),
-      onUpdate: (d) => e.set(d)
-    };
-    return o.type === "inertia" || o.type === "decay" ? bt({ ...y, ...o }) : ht({
-      ...Zt(o, y, t),
-      onUpdate: (d) => {
-        y.onUpdate(d), o.onUpdate && o.onUpdate(d);
-      },
-      onComplete: () => {
-        n && n(), f && f();
-      }
-    });
-  }
-  function u(f) {
-    return e.set(i), n && n(), f && f(), { stop: () => {
-    } };
-  }
-  return !l || !a || o.type === !1 ? u : p;
+function H(e, t) {
+  return e.map((s, n) => s - t[n]);
 }
-function Gt() {
-  const { motionValues: t, stop: e, get: i } = Bt();
-  return { motionValues: t, stop: e, push: (n, o, s, a = {}, l) => {
-    const p = s[n], u = i(n, p, s);
-    if (a && a.immediate) {
-      u.set(o);
-      return;
-    }
-    const f = $t(n, u, o, a, l);
-    u.start(f);
-  } };
+function C(e) {
+  return Math.hypot(...e);
 }
-function Jt(t, e = {}, { motionValues: i, push: r, stop: n } = Gt()) {
-  const o = x(e), s = g(!1);
-  h(
-    i,
-    (f) => {
-      s.value = Object.values(f).filter((y) => y.isAnimating()).length > 0;
-    },
-    {
-      immediate: !0,
-      deep: !0
-    }
-  );
-  const a = (f) => {
-    if (!o || !o[f])
-      throw new Error(`The variant ${f} does not exist.`);
-    return o[f];
-  }, l = (f) => {
-    typeof f == "string" && (f = a(f));
-    const y = Object.entries(f).map(([v, S]) => {
-      if (v !== "transition")
-        return new Promise(
-          (ot) => (
-            // @ts-expect-error - Fix errors later for typescript 5
-            r(v, S, t, f.transition || G(v, f[v]), ot)
-          )
-        );
-    }).filter(Boolean);
-    async function d() {
-      await Promise.all(y), f.transition?.onComplete?.();
-    }
-    return Promise.all([d()]);
-  };
-  return {
-    isAnimating: s,
-    apply: l,
-    set: (f) => {
-      const y = yt(f) ? f : a(f);
-      Object.entries(y).forEach(([d, v]) => {
-        d !== "transition" && r(d, v, t, {
-          immediate: !0
-        });
-      });
-    },
-    leave: async (f) => {
-      let y;
-      if (o && (o.leave && (y = o.leave), !o.leave && o.initial && (y = o.initial)), !y) {
-        f();
-        return;
-      }
-      await l(y), f();
-    },
-    stop: n
-  };
+function mt(e, t, s) {
+  const n = C(t), r = n === 0 ? 0 : 1 / n, i = s === 0 ? 0 : 1 / s, a = i * n, o = t.map((c) => i * c), u = t.map((c) => r * c), f = C(e);
+  return { velocities: o, velocity: a, distance: f, direction: u };
 }
-const L = typeof window < "u", Qt = () => L && (window.onpointerdown === null || R?.TEST), te = () => L && (window.ontouchstart === null || R?.TEST), ee = () => L && (window.onmousedown === null || R?.TEST);
-function ie({ target: t, state: e, variants: i, apply: r }) {
-  const n = x(i), o = g(!1), s = g(!1), a = g(!1), l = A(() => {
-    let u = [...Object.keys(e.value || {})];
-    return n && (n.hovered && (u = [...u, ...Object.keys(n.hovered)]), n.tapped && (u = [...u, ...Object.keys(n.tapped)]), n.focused && (u = [...u, ...Object.keys(n.focused)])), u;
-  }), p = A(() => {
-    const u = {};
-    Object.assign(u, e.value), o.value && n.hovered && Object.assign(u, n.hovered), s.value && n.tapped && Object.assign(u, n.tapped), a.value && n.focused && Object.assign(u, n.focused);
-    for (const f in u)
-      l.value.includes(f) || delete u[f];
-    return u;
-  });
-  n.hovered && (m(t, "mouseenter", () => o.value = !0), m(t, "mouseleave", () => {
-    o.value = !1, s.value = !1;
-  })), n.tapped && (ee() && (m(t, "mousedown", () => s.value = !0), m(t, "mouseup", () => s.value = !1)), Qt() && (m(t, "pointerdown", () => s.value = !0), m(t, "pointerup", () => s.value = !1)), te() && (m(t, "touchstart", () => s.value = !0), m(t, "touchend", () => s.value = !1))), n.focused && (m(t, "focus", () => a.value = !0), m(t, "blur", () => a.value = !1)), h([o, s, a], () => {
-    r(p.value);
-  });
+function M(e) {
+  return Math.sign ? Math.sign(e) : +(e > 0) - +(e < 0) || +e;
 }
-function re({ set: t, target: e, variants: i, variant: r }) {
-  const n = x(i);
-  h(
-    () => e,
-    () => {
-      n && (n.initial && (t("initial"), r.value = "initial"), n.enter && (r.value = "enter"));
-    },
-    {
-      immediate: !0,
-      flush: "pre"
-    }
-  );
+function vt(e, t, s) {
+  return Math.max(t, Math.min(e, s));
 }
-function ne({ state: t, apply: e }) {
-  h(
-    t,
-    (i) => {
-      i && e(i);
-    },
-    {
-      immediate: !0
-    }
-  );
+function yt(e, t) {
+  return Math.pow(e, t * 5);
 }
-function oe({ target: t, variants: e, variant: i }) {
-  const r = x(e);
-  r && (r.visible || r.visibleOnce) && ft(t, ([{ isIntersecting: n }]) => {
-    r.visible ? n ? i.value = "visible" : i.value = "initial" : r.visibleOnce && (n && i.value !== "visibleOnce" ? i.value = "visibleOnce" : i.value || (i.value = "initial"));
-  });
+function z(e, t, s) {
+  return t === 0 || Math.abs(t) === 1 / 0 ? yt(e, s) : e * t * s / (t + s * e);
 }
-function se(t, e = {
-  syncVariants: !0,
-  lifeCycleHooks: !0,
-  visibilityHooks: !0,
-  eventListeners: !0
-}) {
-  e.lifeCycleHooks && re(t), e.syncVariants && ne(t), e.visibilityHooks && oe(t), e.eventListeners && ie(t);
+function R(e, t, s, n = 0.15) {
+  return n === 0 ? vt(e, t, s) : e < t ? -z(t - e, s - t, n) + t : e > s ? +z(e - s, s - t, n) + s : e;
 }
-function Q(t = {}) {
-  const e = V({
-    ...t
-  }), i = g({});
-  return h(
-    e,
-    () => {
-      const r = {};
-      for (const [n, o] of Object.entries(e)) {
-        const s = M(n), a = _(o, s);
-        r[n] = a;
+var _t = Object.defineProperty, wt = (e, t, s) => t in e ? _t(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, T = (e, t, s) => (wt(e, typeof t != "symbol" ? t + "" : t, s), s);
+const v = /* @__PURE__ */ new Map(), bt = (e) => e;
+class St {
+  /**
+   * Creates an instance of a gesture recognizer.
+   * @param stateKey drag, move, pinch, etc.
+   * @param controller the controller attached to the gesture
+   * @param [args] the args that should be passed to the gesture handler
+   */
+  constructor(t, s = []) {
+    this.controller = t, this.args = s, T(this, "debounced", !0), T(this, "setTimeout", (n, r = 140, ...i) => {
+      clearTimeout(this.controller.timeouts[this.stateKey]), this.controller.timeouts[this.stateKey] = window.setTimeout(
+        n,
+        r,
+        ...i
+      );
+    }), T(this, "clearTimeout", () => {
+      clearTimeout(this.controller.timeouts[this.stateKey]);
+    }), T(this, "fireGestureHandler", (n = !1) => {
+      if (this.state._blocked)
+        return this.debounced || (this.state._active = !1, this.clean()), null;
+      if (!n && !this.state.intentional && !this.config.triggerAllEvents)
+        return null;
+      if (this.state.intentional) {
+        const u = this.state.active, f = this.state._active;
+        this.state.active = f, this.state.first = f && !u, this.state.last = u && !f, this.controller.state.shared[this.ingKey] = f;
       }
-      i.value = r;
-    },
-    {
-      immediate: !0,
-      deep: !0
-    }
-  ), {
-    state: e,
-    style: i
+      const r = this.controller.pointerIds.size || this.controller.touchIds.size, i = this.controller.state.shared.buttons > 0 || r > 0, a = {
+        ...this.controller.state.shared,
+        ...this.state,
+        ...this.mapStateValues(this.state),
+        // Sets xy or da to the gesture state values
+        locked: !!document.pointerLockElement,
+        touches: r,
+        down: i
+      }, o = this.handler(a);
+      return this.state.memo = o !== void 0 ? o : this.state.memo, a;
+    }), this.controller = t, this.args = s;
+  }
+  // Returns the gesture config
+  get config() {
+    return this.controller.config[this.stateKey];
+  }
+  // Is the gesture enabled
+  get enabled() {
+    return this.controller.config.enabled && this.config.enabled;
+  }
+  // Returns the controller state for a given gesture
+  get state() {
+    return this.controller.state[this.stateKey];
+  }
+  // Returns the gesture handler
+  get handler() {
+    return this.controller.handlers[this.stateKey];
+  }
+  get transform() {
+    return this.config.transform || this.controller.config.transform || bt;
+  }
+  // Convenience method to update the shared state
+  updateSharedState(t) {
+    Object.assign(this.controller.state.shared, t);
+  }
+  // Convenience method to update the gesture state
+  updateGestureState(t) {
+    Object.assign(this.state, t);
+  }
+  /**
+   * Returns state properties depending on the movement and state.
+   *
+   * Should be overriden for custom behavior, doesn't do anything in the implementation
+   * below.
+   */
+  checkIntentionality(t, s) {
+    return { _intentional: t, _blocked: !1 };
+  }
+  /**
+   * Returns basic movement properties for the gesture based on the next values and current state.
+   */
+  getMovement(t) {
+    const { rubberband: s, threshold: n } = this.config, {
+      _bounds: r,
+      _initial: i,
+      _active: a,
+      _intentional: o,
+      lastOffset: u,
+      movement: f
+    } = this.state, c = this.getInternalMovement(t, this.state), S = this.transform(n).map(Math.abs), E = o[0] === !1 ? N(c[0], S[0]) : o[0], D = o[1] === !1 ? N(c[1], S[1]) : o[1], m = this.checkIntentionality([E, D], c);
+    if (m._blocked)
+      return { ...m, _movement: c, delta: [0, 0] };
+    const d = m._intentional, J = c;
+    let y = [
+      d[0] !== !1 ? c[0] - d[0] : 0,
+      d[1] !== !1 ? c[1] - d[1] : 0
+    ];
+    const Q = x(y, u), A = a ? s : [0, 0];
+    return y = W(r, x(y, i), A), {
+      ...m,
+      intentional: d[0] !== !1 || d[1] !== !1,
+      _initial: i,
+      _movement: J,
+      movement: y,
+      values: t,
+      offset: W(r, Q, A),
+      delta: H(y, f)
+    };
+  }
+  // Cleans the gesture. Can be overriden by gestures.
+  clean() {
+    this.clearTimeout();
+  }
+}
+function N(e, t) {
+  return Math.abs(e) >= t ? M(e) * t : !1;
+}
+function W(e, [t, s], [n, r]) {
+  const [[i, a], [o, u]] = e;
+  return [
+    R(t, i, a, n),
+    R(s, o, u, r)
+  ];
+}
+function O({ state: e }, t, s) {
+  const { timeStamp: n, type: r } = t, i = e.values, a = s ? 0 : n - e.startTime;
+  return { _lastEventType: r, event: t, timeStamp: n, elapsedTime: a, previous: i };
+}
+function Tt({ state: e, config: t, stateKey: s, args: n }, r, i) {
+  const a = e.offset, o = i.timeStamp, { initial: u, bounds: f } = t, c = {
+    ...P()[s],
+    _active: !0,
+    args: n,
+    values: r,
+    initial: r,
+    offset: a,
+    lastOffset: a,
+    startTime: o
   };
-}
-function k(t, e) {
-  h(
-    () => ut(t),
-    (i) => {
-      i && e(i);
-    },
-    {
-      immediate: !0
-    }
-  );
-}
-const ae = {
-  x: "translateX",
-  y: "translateY",
-  z: "translateZ"
-};
-function tt(t = {}, e = !0) {
-  const i = V({ ...t }), r = g("");
-  return h(
-    i,
-    (n) => {
-      let o = "", s = !1;
-      if (e && (n.x || n.y || n.z)) {
-        const a = [n.x || 0, n.y || 0, n.z || 0].map((l) => _(l, c)).join(",");
-        o += `translate3d(${a}) `, s = !0;
-      }
-      for (const [a, l] of Object.entries(n)) {
-        if (e && (a === "x" || a === "y" || a === "z"))
-          continue;
-        const p = M(a), u = _(l, p);
-        o += `${ae[a] || a}(${u}) `;
-      }
-      e && !s && (o += "translateZ(0px) "), r.value = o.trim();
-    },
-    {
-      immediate: !0,
-      deep: !0
-    }
-  ), {
-    state: i,
-    transform: r
+  return {
+    ...c,
+    _initial: K(u, c),
+    _bounds: K(f, c)
   };
 }
-const ce = ["", "X", "Y", "Z"], le = ["perspective", "translate", "scale", "rotate", "skew"], et = ["transformPerspective", "x", "y", "z"];
-le.forEach((t) => {
-  ce.forEach((e) => {
-    const i = t + e;
-    et.push(i);
-  });
-});
-const ue = new Set(et);
-function q(t) {
-  return ue.has(t);
-}
-const fe = /* @__PURE__ */ new Set(["originX", "originY", "originZ"]);
-function it(t) {
-  return fe.has(t);
-}
-function pe(t) {
-  const e = {}, i = {};
-  return Object.entries(t).forEach(([r, n]) => {
-    q(r) || it(r) ? e[r] = n : i[r] = n;
-  }), { transform: e, style: i };
-}
-function B(t) {
-  const { transform: e, style: i } = pe(t), { transform: r } = tt(e), { style: n } = Q(i);
-  return r.value && (n.value.transform = r.value), n.value;
-}
-function ye(t, e) {
-  let i, r;
-  const { state: n, style: o } = Q();
-  return k(t, (s) => {
-    r = s;
-    for (const a of Object.keys(J))
-      s.style[a] === null || s.style[a] === "" || q(a) || it(a) || (n[a] = s.style[a]);
-    i && Object.entries(i).forEach(([a, l]) => s.style[a] = l), e && e(n);
-  }), h(
-    o,
-    (s) => {
-      if (!r) {
-        i = s;
-        return;
-      }
-      for (const a in s) r.style[a] = s[a];
-    },
-    {
-      immediate: !0
+class It extends St {
+  /**
+   * Returns the real movement (without taking intentionality into account)
+   */
+  getInternalMovement(t, s) {
+    return H(t, s.initial);
+  }
+  /**
+   * In coordinates-based gesture, this function will detect the first intentional axis,
+   * lock the gesture axis if lockDirection is specified in the config, block the gesture
+   * if the first intentional axis doesn't match the specified axis in config.
+   */
+  checkIntentionality(t, s) {
+    if (t[0] === !1 && t[1] === !1)
+      return { _intentional: t, axis: this.state.axis };
+    const [n, r] = s.map(Math.abs), i = this.state.axis || (n > r ? "x" : n < r ? "y" : void 0);
+    return !this.config.axis && !this.config.lockDirection ? { _intentional: t, _blocked: !1, axis: i } : i ? this.config.axis && i !== this.config.axis ? { _intentional: t, _blocked: !0, axis: i } : (t[i === "x" ? 1 : 0] = !1, { _intentional: t, _blocked: !1, axis: i }) : { _intentional: [!1, !1], _blocked: !1, axis: i };
+  }
+  getKinematics(t, s) {
+    const n = this.getMovement(t);
+    if (!n._blocked) {
+      const r = s.timeStamp - this.state.timeStamp;
+      Object.assign(
+        n,
+        mt(n.movement, n.delta, r)
+      );
     }
-  ), {
-    style: n
-  };
+    return n;
+  }
+  mapStateValues(t) {
+    return { xy: t.values, vxvy: t.velocities };
+  }
 }
-function de(t) {
-  const e = t.trim().split(/\) |\)/);
-  if (e.length === 1)
-    return {};
-  const i = (r) => r.endsWith("px") || r.endsWith("deg") ? Number.parseFloat(r) : Number.isNaN(Number(r)) ? Number(r) : r;
-  return e.reduce((r, n) => {
-    if (!n)
-      return r;
-    const [o, s] = n.split("("), l = s.split(",").map((u) => i(u.endsWith(")") ? u.replace(")", "") : u.trim())), p = l.length === 1 ? l[0] : l;
-    return {
-      ...r,
-      [o]: p
-    };
-  }, {});
+var Et = Object.defineProperty, Dt = (e, t, s) => t in e ? Et(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, l = (e, t, s) => (Dt(e, typeof t != "symbol" ? t + "" : t, s), s);
+const Ot = 3;
+function U(e) {
+  "persist" in e && typeof e.persist == "function" && e.persist();
 }
-function me(t, e) {
-  Object.entries(de(e)).forEach(([i, r]) => {
-    const n = ["x", "y", "z"];
-    if (i === "translate3d") {
-      if (r === 0) {
-        n.forEach((o) => t[o] = 0);
+class Pt extends It {
+  constructor() {
+    super(...arguments), l(this, "ingKey", "dragging"), l(this, "stateKey", "drag"), l(this, "setPointerCapture", (t) => {
+      if (this.config.useTouch || document.pointerLockElement)
         return;
+      const { target: s, pointerId: n } = t;
+      s && "setPointerCapture" in s && s.setPointerCapture(n), this.updateGestureState({
+        _dragTarget: s,
+        _dragPointerId: n
+      });
+    }), l(this, "releasePointerCapture", () => {
+      if (this.config.useTouch || document.pointerLockElement)
+        return;
+      const { _dragTarget: t, _dragPointerId: s } = this.state;
+      if (s && t && "releasePointerCapture" in t && (!("hasPointerCapture" in t) || t.hasPointerCapture(s)))
+        try {
+          t.releasePointerCapture(s);
+        } catch {
+        }
+    }), l(this, "preventScroll", (t) => {
+      this.state._dragPreventScroll && t.cancelable && t.preventDefault();
+    }), l(this, "getEventId", (t) => this.config.useTouch ? t.changedTouches[0].identifier : t.pointerId), l(this, "isValidEvent", (t) => this.state._pointerId === this.getEventId(t)), l(this, "shouldPreventWindowScrollY", this.config.preventWindowScrollY && this.controller.supportsTouchEvents), l(this, "setUpWindowScrollDetection", (t) => {
+      U(t), dt(
+        this.controller,
+        this.stateKey,
+        [
+          ["touchmove", this.preventScroll],
+          ["touchend", this.clean.bind(this)],
+          ["touchcancel", this.clean.bind(this)]
+        ],
+        { passive: !1 }
+      ), this.setTimeout(this.startDrag.bind(this), 250, t);
+    }), l(this, "setUpDelayedDragTrigger", (t) => {
+      this.state._dragDelayed = !0, U(t), this.setTimeout(this.startDrag.bind(this), this.config.delay, t);
+    }), l(this, "setStartState", (t) => {
+      const s = G(t, this.transform);
+      this.updateSharedState(L(t)), this.updateGestureState({
+        ...Tt(this, s, t),
+        ...O(this, t, !0),
+        _pointerId: this.getEventId(t)
+        // setting pointerId locks the gesture to this specific event
+      }), this.updateGestureState(this.getMovement(s));
+    }), l(this, "onDragStart", (t) => {
+      lt(this.controller, t), !(!this.enabled || this.state._active) && (this.setStartState(t), this.setPointerCapture(t), this.shouldPreventWindowScrollY ? this.setUpWindowScrollDetection(t) : this.config.delay > 0 ? this.setUpDelayedDragTrigger(t) : this.startDrag(t, !0));
+    }), l(this, "onDragChange", (t) => {
+      if (
+        // if the gesture was canceled or
+        this.state.canceled || // if onDragStart wasn't fired or
+        !this.state._active || // if the event pointerId doesn't match the one that initiated the drag
+        !this.isValidEvent(t) || // if the event has the same timestamp as the previous event
+        // note that checking type equality is ONLY for tests ¯\_(ツ)_/¯
+        this.state._lastEventType === t.type && t.timeStamp === this.state.timeStamp
+      )
+        return;
+      let s;
+      if (document.pointerLockElement) {
+        const { movementX: u, movementY: f } = t;
+        s = x(this.transform([u, f]), this.state.values);
+      } else
+        s = G(t, this.transform);
+      const n = this.getKinematics(s, t);
+      if (!this.state._dragStarted) {
+        if (this.state._dragDelayed) {
+          this.startDrag(t);
+          return;
+        }
+        if (this.shouldPreventWindowScrollY)
+          if (!this.state._dragPreventScroll && n.axis)
+            if (n.axis === "x")
+              this.startDrag(t);
+            else {
+              this.state._active = !1;
+              return;
+            }
+          else
+            return;
+        else
+          return;
       }
-      r.forEach((o, s) => t[n[s]] = o);
-      return;
+      const r = L(t);
+      this.updateSharedState(r);
+      const i = O(this, t), a = C(n._movement);
+      let { _dragIsTap: o } = this.state;
+      o && a >= Ot && (o = !1), this.updateGestureState({ ...i, ...n, _dragIsTap: o }), this.fireGestureHandler();
+    }), l(this, "onDragEnd", (t) => {
+      if (ut(this.controller, t), !this.isValidEvent(t) || (this.clean(), !this.state._active))
+        return;
+      this.state._active = !1;
+      const s = this.state._dragIsTap, [n, r] = this.state.velocities, [i, a] = this.state.movement, [o, u] = this.state._intentional, [f, c] = this.config.swipeVelocity, [S, E] = this.config.swipeDistance, D = this.config.swipeDuration, m = {
+        ...O(this, t),
+        ...this.getMovement(this.state.values)
+      }, d = [0, 0];
+      m.elapsedTime < D && (o !== !1 && Math.abs(n) > f && Math.abs(i) > S && (d[0] = M(n)), u !== !1 && Math.abs(r) > c && Math.abs(a) > E && (d[1] = M(r))), this.updateSharedState({ buttons: 0 }), this.updateGestureState({ ...m, tap: s, swipe: d }), this.fireGestureHandler(this.config.filterTaps && s === !0);
+    }), l(this, "clean", () => {
+      super.clean(), this.state._dragStarted = !1, this.releasePointerCapture(), ht(this.controller, this.stateKey);
+    }), l(this, "onCancel", () => {
+      this.state.canceled || (this.updateGestureState({ canceled: !0, _active: !1 }), this.updateSharedState({ buttons: 0 }), nt(this.fireGestureHandler));
+    }), l(this, "onClick", (t) => {
+      this.state._dragIsTap || t.stopPropagation();
+    });
+  }
+  startDrag(t, s = !1) {
+    // if the gesture isn't active (probably means)
+    !this.state._active || // if the drag has already started we should ignore subsequent attempts
+    this.state._dragStarted || (s || this.setStartState(t), this.updateGestureState({
+      _dragStarted: !0,
+      _dragPreventScroll: !0,
+      cancel: this.onCancel
+    }), this.clearTimeout(), this.fireGestureHandler());
+  }
+  addBindings(t) {
+    if (this.config.useTouch ? (p(t, "onTouchStart", this.onDragStart), p(t, "onTouchMove", this.onDragChange), p(t, "onTouchEnd", this.onDragEnd), p(t, "onTouchCancel", this.onDragEnd)) : (p(t, "onPointerDown", this.onDragStart), p(t, "onPointerMove", this.onDragChange), p(t, "onPointerUp", this.onDragEnd), p(t, "onPointerCancel", this.onDragEnd)), this.config.filterTaps) {
+      const s = this.controller.config.eventOptions.capture ? "onClick" : "onClickCapture";
+      p(t, s, this.onClick);
     }
-    if (r = Number.parseFloat(`${r}`), i === "translateX") {
-      t.x = r;
-      return;
+  }
+}
+function xt(e, t) {
+  let s, n = [], r, i = !1;
+  function a(...o) {
+    return i && s === this && t(o, n) || (r = e.apply(this, o), i = !0, s = this, n = o), r;
+  }
+  return a;
+}
+function I(e, t) {
+  if (e === t)
+    return !0;
+  if (e && t && typeof e == "object" && typeof t == "object") {
+    if (e.constructor !== t.constructor)
+      return !1;
+    let s, n, r;
+    if (Array.isArray(e)) {
+      if (s = e.length, s !== t.length)
+        return !1;
+      for (n = s; n-- !== 0; )
+        if (!I(e[n], t[n]))
+          return !1;
+      return !0;
     }
-    if (i === "translateY") {
-      t.y = r;
-      return;
+    let i;
+    if (typeof Map == "function" && e instanceof Map && t instanceof Map) {
+      if (e.size !== t.size)
+        return !1;
+      for (i = e.entries(); !(n = i.next()).done; )
+        if (!t.has(n.value[0]))
+          return !1;
+      for (i = e.entries(); !(n = i.next()).done; )
+        if (!I(n.value[1], t.get(n.value[0])))
+          return !1;
+      return !0;
     }
-    if (i === "translateZ") {
-      t.z = r;
-      return;
+    if (typeof Set == "function" && e instanceof Set && t instanceof Set) {
+      if (e.size !== t.size)
+        return !1;
+      for (i = e.entries(); !(n = i.next()).done; )
+        if (!t.has(n.value[0]))
+          return !1;
+      return !0;
     }
-    t[i] = r;
-  });
-}
-function be(t, e) {
-  let i, r;
-  const { state: n, transform: o } = tt();
-  return k(t, (s) => {
-    r = s, s.style.transform && me(n, s.style.transform), i && (s.style.transform = i), e && e(n);
-  }), h(
-    o,
-    (s) => {
-      if (!r) {
-        i = s;
-        return;
-      }
-      r.style.transform = s;
-    },
-    {
-      immediate: !0
+    if (e.constructor === RegExp)
+      return e.source === t.source && e.flags === t.flags;
+    if (e.valueOf !== Object.prototype.valueOf)
+      return e.valueOf() === t.valueOf();
+    if (e.toString !== Object.prototype.toString)
+      return e.toString() === t.toString();
+    if (r = Object.keys(e), s = r.length, s !== Object.keys(t).length)
+      return !1;
+    for (n = s; n-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(t, r[n]))
+        return !1;
+    if (typeof Element < "u" && e instanceof Element)
+      return !1;
+    for (n = s; n-- !== 0; )
+      if (!(r[n] === "_owner" && e.$$typeof) && !I(e[r[n]], t[r[n]]))
+        return !1;
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function Ct(e, t) {
+  try {
+    return I(e, t);
+  } catch (s) {
+    if ((s.message || "").match(/stack|recursion/i))
+      return console.warn("react-fast-compare cannot handle circular refs"), !1;
+    throw s;
+  }
+}
+function k(e = {}, t) {
+  const s = {};
+  for (const [n, r] of Object.entries(t))
+    switch (typeof r) {
+      case "function":
+        s[n] = r.call(s, e[n], n, e);
+        break;
+      case "object":
+        s[n] = k(e[n], r);
+        break;
+      case "boolean":
+        r && (s[n] = e[n]);
+        break;
     }
-  ), {
-    transform: n
-  };
-}
-function he(t) {
-  return Object.entries(t);
-}
-function ve(t, e) {
-  const i = V({}), r = (s) => Object.entries(s).forEach(([a, l]) => i[a] = l), { style: n } = ye(t, r), { transform: o } = be(t, r);
-  return h(
-    i,
-    (s) => {
-      he(s).forEach(([a, l]) => {
-        const p = q(a) ? o : n;
-        p[a] && p[a] === l || (p[a] = l);
-      });
-    },
-    {
-      immediate: !0,
-      deep: !0
+  return s;
+}
+const Mt = 180, kt = 0.15, At = 0.5, Lt = 50, Gt = 250, Kt = {
+  threshold(e = 0) {
+    return g(e);
+  },
+  rubberband(e = 0) {
+    switch (e) {
+      case !0:
+        return g(kt);
+      case !1:
+        return g(0);
+      default:
+        return g(e);
     }
-  ), k(t, () => e), {
-    motionProperties: i,
-    style: n,
-    transform: o
-  };
-}
-function ge(t = {}) {
-  const e = x(t), i = g();
-  return {
-    state: A(() => {
-      if (i.value)
-        return e[i.value];
-    }),
-    variant: i
-  };
-}
-function Oe(t, e = {}, i) {
-  const { motionProperties: r } = ve(t), { variant: n, state: o } = ge(e), s = Jt(r, e), a = {
-    target: t,
-    variant: n,
-    variants: e,
-    state: o,
-    motionProperties: r,
-    ...s
-  };
-  return se(a, i), a;
-}
-const Te = {
-  initial: {
-    opacity: 0
-  },
-  enter: {
-    opacity: 1
-  }
-}, Ae = {
-  initial: {
-    opacity: 0
-  },
-  visible: {
-    opacity: 1
-  }
-}, xe = {
-  initial: {
-    opacity: 0
-  },
-  visibleOnce: {
-    opacity: 1
-  }
-}, je = {
-  initial: {
-    scale: 0,
-    opacity: 0
-  },
-  enter: {
-    scale: 1,
-    opacity: 1
-  }
-}, Ve = {
-  initial: {
-    scale: 0,
-    opacity: 0
-  },
-  visible: {
-    scale: 1,
-    opacity: 1
-  }
-}, Se = {
-  initial: {
-    scale: 0,
-    opacity: 0
-  },
-  visibleOnce: {
-    scale: 1,
-    opacity: 1
-  }
-}, Ce = {
-  initial: {
-    x: -100,
-    rotate: 90,
-    opacity: 0
-  },
-  enter: {
-    x: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, Ee = {
-  initial: {
-    x: -100,
-    rotate: 90,
-    opacity: 0
-  },
-  visible: {
-    x: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, Ne = {
-  initial: {
-    x: -100,
-    rotate: 90,
-    opacity: 0
-  },
-  visibleOnce: {
-    x: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, Pe = {
-  initial: {
-    x: 100,
-    rotate: -90,
-    opacity: 0
-  },
-  enter: {
-    x: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, _e = {
-  initial: {
-    x: 100,
-    rotate: -90,
-    opacity: 0
-  },
-  visible: {
-    x: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, we = {
-  initial: {
-    x: 100,
-    rotate: -90,
-    opacity: 0
-  },
-  visibleOnce: {
-    x: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, Re = {
-  initial: {
-    y: -100,
-    rotate: -90,
-    opacity: 0
-  },
-  enter: {
-    y: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, Me = {
-  initial: {
-    y: -100,
-    rotate: -90,
-    opacity: 0
-  },
-  visible: {
-    y: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, Le = {
-  initial: {
-    y: -100,
-    rotate: -90,
-    opacity: 0
-  },
-  visibleOnce: {
-    y: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, ke = {
-  initial: {
-    y: 100,
-    rotate: 90,
-    opacity: 0
   },
-  enter: {
-    y: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, qe = {
-  initial: {
-    y: 100,
-    rotate: 90,
-    opacity: 0
-  },
-  visible: {
-    y: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, Be = {
-  initial: {
-    y: 100,
-    rotate: 90,
-    opacity: 0
-  },
-  visibleOnce: {
-    y: 0,
-    rotate: 0,
-    opacity: 1
-  }
-}, De = {
-  initial: {
-    x: -100,
-    opacity: 0
-  },
-  enter: {
-    x: 0,
-    opacity: 1
-  }
-}, Fe = {
-  initial: {
-    x: -100,
-    opacity: 0
-  },
-  visible: {
-    x: 0,
-    opacity: 1
-  }
-}, ze = {
-  initial: {
-    x: -100,
-    opacity: 0
-  },
-  visibleOnce: {
-    x: 0,
-    opacity: 1
-  }
-}, Ie = {
-  initial: {
-    x: 100,
-    opacity: 0
-  },
-  enter: {
-    x: 0,
-    opacity: 1
-  }
-}, Ue = {
-  initial: {
-    x: 100,
-    opacity: 0
-  },
-  visible: {
-    x: 0,
-    opacity: 1
-  }
-}, We = {
-  initial: {
-    x: 100,
-    opacity: 0
-  },
-  visibleOnce: {
-    x: 0,
-    opacity: 1
-  }
-}, Xe = {
-  initial: {
-    y: -100,
-    opacity: 0
-  },
-  enter: {
-    y: 0,
-    opacity: 1
-  }
-}, Ye = {
-  initial: {
-    y: -100,
-    opacity: 0
-  },
-  visible: {
-    y: 0,
-    opacity: 1
-  }
-}, Ze = {
-  initial: {
-    y: -100,
-    opacity: 0
-  },
-  visibleOnce: {
-    y: 0,
-    opacity: 1
-  }
-}, He = {
-  initial: {
-    y: 100,
-    opacity: 0
-  },
-  enter: {
-    y: 0,
-    opacity: 1
-  }
-}, Ke = {
-  initial: {
-    y: 100,
-    opacity: 0
-  },
-  visible: {
-    y: 0,
-    opacity: 1
-  }
-}, $e = {
-  initial: {
-    y: 100,
-    opacity: 0
+  enabled(e = !0) {
+    return e;
   },
-  visibleOnce: {
-    y: 0,
-    opacity: 1
-  }
-}, Y = {
-  __proto__: null,
-  fade: Te,
-  fadeVisible: Ae,
-  fadeVisibleOnce: xe,
-  pop: je,
-  popVisible: Ve,
-  popVisibleOnce: Se,
-  rollBottom: ke,
-  rollLeft: Ce,
-  rollRight: Pe,
-  rollTop: Re,
-  rollVisibleBottom: qe,
-  rollVisibleLeft: Ee,
-  rollVisibleOnceBottom: Be,
-  rollVisibleOnceLeft: Ne,
-  rollVisibleOnceRight: we,
-  rollVisibleOnceTop: Le,
-  rollVisibleRight: _e,
-  rollVisibleTop: Me,
-  slideBottom: He,
-  slideLeft: De,
-  slideRight: Ie,
-  slideTop: Xe,
-  slideVisibleBottom: Ke,
-  slideVisibleLeft: Fe,
-  slideVisibleOnceBottom: $e,
-  slideVisibleOnceLeft: ze,
-  slideVisibleOnceRight: We,
-  slideVisibleOnceTop: Ze,
-  slideVisibleRight: Ue,
-  slideVisibleTop: Ye
-}, Ge = /* @__PURE__ */ Symbol(
-  ""
-), rt = {
-  // Preset to be loaded
-  preset: {
-    type: String,
-    required: !1
+  triggerAllEvents(e = !1) {
+    return e;
   },
-  // Instance
-  instance: {
-    type: Object,
-    required: !1
+  initial(e = 0) {
+    return typeof e == "function" ? e : g(e);
   },
-  // Variants
-  variants: {
-    type: Object,
-    required: !1
+  transform: !0
+}, q = {
+  ...Kt,
+  axis: !0,
+  lockDirection(e = !1) {
+    return e;
   },
-  // Initial variant
-  initial: {
-    type: Object,
-    required: !1
+  bounds(e = {}) {
+    if (typeof e == "function")
+      return (i) => q.bounds(e(i));
+    const {
+      left: t = -1 / 0,
+      right: s = 1 / 0,
+      top: n = -1 / 0,
+      bottom: r = 1 / 0
+    } = e;
+    return [
+      [t, s],
+      [n, r]
+    ];
+  }
+}, zt = typeof window < "u" && window.document && window.document.createElement, Rt = {
+  enabled(e = !0) {
+    return e;
   },
-  // Lifecycle hooks variants
-  enter: {
-    type: Object,
-    required: !1
+  domTarget: !0,
+  window(e = zt ? window : void 0) {
+    return e;
   },
-  leave: {
-    type: Object,
-    required: !1
+  eventOptions({ passive: e = !0, capture: t = !1 } = {}) {
+    return { passive: e, capture: t };
   },
-  // Intersection observer variants
-  visible: {
-    type: Object,
-    required: !1
+  transform: !0
+}, Nt = {
+  ...q,
+  useTouch(e = !0) {
+    return e && j();
   },
-  visibleOnce: {
-    type: Object,
-    required: !1
+  preventWindowScrollY(e = !1) {
+    return e;
   },
-  // Event listeners variants
-  hovered: {
-    type: Object,
-    required: !1
+  threshold(e, t, { filterTaps: s = !1, lockDirection: n = !1, axis: r = void 0 }) {
+    const i = g(
+      e,
+      s ? 3 : n || r ? 1 : 0
+    );
+    return this.filterTaps = s, i;
   },
-  tapped: {
-    type: Object,
-    required: !1
+  swipeVelocity(e = At) {
+    return g(e);
   },
-  focused: {
-    type: Object,
-    required: !1
+  swipeDistance(e = Lt) {
+    return g(e);
   },
-  // Helpers
-  delay: {
-    type: [Number, String],
-    required: !1
+  swipeDuration(e = Gt) {
+    return e;
   },
-  duration: {
-    type: [Number, String],
-    required: !1
+  delay(e = 0) {
+    switch (e) {
+      case !0:
+        return Mt;
+      case !1:
+        return 0;
+      default:
+        return e;
+    }
   }
 };
-function Je(t) {
-  return Object.prototype.toString.call(t) === "[object Object]";
+function Wt(e) {
+  return k(
+    e,
+    Rt
+  );
 }
-function w(t) {
-  if (Array.isArray(t))
-    return t.map(w);
-  if (Je(t)) {
-    const e = {};
-    for (const i in t)
-      e[i] = w(t[i]);
-    return e;
-  }
-  return t;
+function Ut(e = {}) {
+  return k(
+    e,
+    Nt
+  );
 }
-function nt(t) {
-  const e = V({}), i = ct(Ge, {}), r = A(() => t.preset == null ? {} : i != null && t.preset in i ? structuredClone(lt(i)[t.preset]) : t.preset in Y ? structuredClone(Y[t.preset]) : {}), n = A(() => ({
-    initial: t.initial,
-    enter: t.enter,
-    leave: t.leave,
-    visible: t.visible,
-    visibleOnce: t.visibleOnce,
-    hovered: t.hovered,
-    tapped: t.tapped,
-    focused: t.focused
-  }));
-  function o(l, p) {
-    for (const u of ["delay", "duration"]) {
-      if (p[u] == null)
-        continue;
-      const f = Number.parseInt(
-        p[u]
-      );
-      for (const y of ["enter", "visible", "visibleOnce"]) {
-        const d = l[y];
-        d != null && (d.transition ??= {}, d.transition[u] = f);
-      }
-    }
-    return l;
-  }
-  const s = A(() => {
-    const l = st(
-      {},
-      n.value,
-      r.value,
-      t.variants || {}
-    );
-    return o({ ...l }, t);
+function jt({
+  domTarget: e,
+  eventOptions: t,
+  window: s,
+  enabled: n,
+  ...r
+}) {
+  const i = Wt({
+    domTarget: e,
+    eventOptions: t,
+    window: s,
+    enabled: n
   });
-  function a(l, p, u) {
-    l.props ??= {}, l.props.style ??= {}, l.props.style = { ...l.props.style, ...u };
-    const f = o(
-      w(s.value),
-      l.props
-    );
-    return l.props.onVnodeMounted = ({ el: y }) => {
-      e[p] = Oe(
-        y,
-        f
-      );
-    }, l.props.onVnodeUpdated = ({ el: y }) => {
-      const d = B(e[p].state);
-      for (const [v, S] of Object.entries(d))
-        y.style[v] = S;
-    }, l;
-  }
-  return {
-    motionConfig: s,
-    setNodeInstance: a
-  };
+  return i.drag = Ut(r), i;
+}
+function Vt(e, t, s = {}) {
+  const n = Yt(e), r = new ct(n);
+  return r.config = t, r.handlers = e, r.nativeRefs = s, tt() && !t.manual && (et(r.bind), st(r.clean)), r;
+}
+function Yt(e) {
+  const t = /* @__PURE__ */ new Set();
+  return e.drag && t.add(v.get("drag")), e.wheel && t.add(v.get("wheel")), e.scroll && t.add(v.get("scroll")), e.move && t.add(v.get("move")), e.pinch && t.add(v.get("pinch")), e.hover && t.add(v.get("hover")), t;
+}
+function Ft(e, t = {}) {
+  v.set("drag", Pt);
+  const s = Z();
+  return s.value || (s.value = xt(jt, Ct)), Vt({ drag: e }, s.value(t));
 }
-Z({
-  name: "Motion",
-  props: {
-    ...rt,
-    is: {
-      type: [String, Object],
-      default: "div"
-    }
-  },
-  setup(t) {
-    const e = H(), { motionConfig: i, setNodeInstance: r } = nt(t);
-    return () => {
-      const n = B(i.value.initial || {}), o = K(t.is, void 0, e);
-      return r(o, 0, n), o;
-    };
-  }
-});
-Z({
-  name: "MotionGroup",
-  props: {
-    ...rt,
-    is: {
-      type: [String, Object],
-      required: !1
-    }
-  },
-  setup(t) {
-    const e = H(), { motionConfig: i, setNodeInstance: r } = nt(t);
-    return () => {
-      const n = B(i.value.initial || {}), o = e.default?.() || [];
-      for (let s = 0; s < o.length; s++) {
-        const a = o[s];
-        a.type === at && Array.isArray(a.children) ? a.children.forEach(function l(p, u) {
-          if (p != null) {
-            if (Array.isArray(p)) {
-              l(p, u);
-              return;
-            }
-            typeof p == "object" && r(p, u, n);
-          }
-        }) : r(a, s, n);
-      }
-      return t.is ? K(t.is, void 0, o) : o;
-    };
-  }
-});
 export {
-  Te as fade,
-  Ae as fadeVisible,
-  xe as fadeVisibleOnce,
-  je as pop,
-  Ve as popVisible,
-  Se as popVisibleOnce,
-  Q as reactiveStyle,
-  tt as reactiveTransform,
-  ke as rollBottom,
-  Ce as rollLeft,
-  Pe as rollRight,
-  Re as rollTop,
-  qe as rollVisibleBottom,
-  Ee as rollVisibleLeft,
-  Be as rollVisibleOnceBottom,
-  Ne as rollVisibleOnceLeft,
-  we as rollVisibleOnceRight,
-  Le as rollVisibleOnceTop,
-  _e as rollVisibleRight,
-  Me as rollVisibleTop,
-  He as slideBottom,
-  De as slideLeft,
-  Ie as slideRight,
-  Xe as slideTop,
-  Ke as slideVisibleBottom,
-  Fe as slideVisibleLeft,
-  $e as slideVisibleOnceBottom,
-  ze as slideVisibleOnceLeft,
-  We as slideVisibleOnceRight,
-  Ze as slideVisibleOnceTop,
-  Ue as slideVisibleRight,
-  Ye as slideVisibleTop,
-  ye as useElementStyle,
-  be as useElementTransform,
-  Oe as useMotion,
-  Jt as useMotionControls,
-  se as useMotionFeatures,
-  ve as useMotionProperties,
-  Gt as useMotionTransitions,
-  ge as useMotionVariants
+  x as addV,
+  R as rubberbandIfOutOfBounds,
+  H as subV,
+  Ft as useDrag
 };