@quoreadmin/ui 1.9.3 → 1.10.1

package/dist/index181.js

@@ -1,4 +1,774 @@
-const C = "data:image/svg+xml,%3csvg%20width='118'%20height='99'%20viewBox='0%200%20118%2099'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M104.165%2059.815C107.107%2062.7762%20108.893%2066.692%20109.201%2070.8549C109.508%2075.0179%20108.317%2079.1536%20105.842%2082.515L105.642%2082.782L105.412%2083.082L117.521%2095.245C117.828%2095.5546%20118%2095.973%20118%2096.409C118%2096.845%20117.828%2097.2634%20117.521%2097.573C117.232%2097.8651%20116.844%2098.0376%20116.434%2098.0561C116.023%2098.0746%20115.621%2097.9378%20115.307%2097.673L115.207%2097.573L103.122%2085.438L102.822%2085.682C99.4939%2088.3942%2095.2763%2089.772%2090.9889%2089.5476C86.7016%2089.3233%2082.6508%2087.5127%2079.624%2084.468C76.3686%2081.1921%2074.5414%2076.7614%2074.5414%2072.143C74.5414%2067.5247%2076.3686%2063.0939%2079.624%2059.818C81.2316%2058.2001%2083.1433%2056.916%2085.2491%2056.0397C87.3548%2055.1634%2089.6131%2054.7121%2091.8939%2054.7118C94.1747%2054.7115%2096.4331%2055.1622%2098.539%2056.0381C100.645%2056.9139%20102.557%2058.1975%20104.165%2059.815ZM81.935%2062.131C79.2951%2064.7964%2077.8142%2068.3961%2077.8142%2072.1475C77.8142%2075.8989%2079.2951%2079.4986%2081.935%2082.164C83.2368%2083.4792%2084.7865%2084.5233%2086.4944%2085.2358C88.2022%2085.9484%2090.0344%2086.3153%2091.885%2086.3153C93.7355%2086.3153%2095.5678%2085.9484%2097.2756%2085.2358C98.9835%2084.5233%20100.533%2083.4792%20101.835%2082.164C104.475%2079.4986%20105.956%2075.8989%20105.956%2072.1475C105.956%2068.3961%20104.475%2064.7964%20101.835%2062.131C100.533%2060.8158%2098.9835%2059.7717%2097.2756%2059.0592C95.5678%2058.3466%2093.7355%2057.9797%2091.885%2057.9797C90.0344%2057.9797%2088.2022%2058.3466%2086.4944%2059.0592C84.7865%2059.7717%2083.2368%2060.8158%2081.935%2062.131ZM31.4%2075.042V76.442C31.4001%2076.5544%2031.4224%2076.6656%2031.4656%2076.7694C31.5087%2076.8731%2031.5719%2076.9673%2031.6515%2077.0466C31.7311%2077.126%2031.8255%2077.1888%2031.9294%2077.2316C32.0333%2077.2744%2032.1446%2077.2963%2032.257%2077.296H72.357C72.5818%2078.1673%2072.8638%2079.0228%2073.201%2079.857H32.258C31.3506%2079.8589%2030.4796%2079.5003%2029.8366%2078.86C29.1935%2078.2198%2028.8311%2077.3504%2028.829%2076.443V75.043L31.4%2075.042ZM86.162%2022C87.0694%2021.9981%2087.9404%2022.3568%2088.5834%2022.997C89.2265%2023.6372%2089.5889%2024.5066%2089.591%2025.414V51.808C88.7243%2051.9101%2087.8652%2052.0684%2087.019%2052.282V25.414C87.0189%2025.3016%2086.9966%2025.1904%2086.9534%2025.0867C86.9103%2024.9829%2086.8471%2024.8887%2086.7675%2024.8094C86.6879%2024.7301%2086.5935%2024.6672%2086.4896%2024.6244C86.3857%2024.5816%2086.2744%2024.5597%2086.162%2024.56H25.429C25.3166%2024.5597%2025.2053%2024.5816%2025.1014%2024.6244C24.9975%2024.6672%2024.9031%2024.7301%2024.8235%2024.8094C24.7439%2024.8887%2024.6807%2024.9829%2024.6376%2025.0867C24.5944%2025.1904%2024.5721%2025.3016%2024.572%2025.414V69.587C24.5721%2069.6994%2024.5944%2069.8106%2024.6376%2069.9144C24.6807%2070.0181%2024.7439%2070.1123%2024.8235%2070.1916C24.9031%2070.271%2024.9975%2070.3338%2025.1014%2070.3766C25.2053%2070.4194%2025.3166%2070.4413%2025.429%2070.441H71.766C71.697%2071.2932%2071.6806%2072.1488%2071.717%2073.003H25.429C24.5216%2073.0049%2023.6506%2072.6463%2023.0076%2072.006C22.3645%2071.3658%2022.0021%2070.4964%2022%2069.589V25.414C22.0021%2024.5066%2022.3645%2023.6372%2023.0076%2022.997C23.6506%2022.3568%2024.5216%2021.9981%2025.429%2022H86.162ZM77.701%2054.948C77.8695%2054.9484%2078.0362%2054.982%2078.1918%2055.0468C78.3473%2055.1117%2078.4885%2055.2065%2078.6073%2055.3259C78.7262%2055.4453%2078.8204%2055.587%2078.8845%2055.7428C78.9486%2055.8986%2078.9814%2056.0655%2078.981%2056.234C78.9811%2056.2983%2078.9764%2056.3624%2078.967%2056.426C78.557%2056.7693%2078.159%2057.1327%2077.773%2057.516H77.701H34.374C34.0329%2057.516%2033.7058%2057.3805%2033.4647%2057.1393C33.2235%2056.8982%2033.088%2056.5711%2033.088%2056.23C33.088%2055.8889%2033.2235%2055.5618%2033.4647%2055.3207C33.7058%2055.0795%2034.0329%2054.944%2034.374%2054.944L77.701%2054.948ZM92.991%2028.859C93.8984%2028.8571%2094.7694%2029.2158%2095.4124%2029.856C96.0555%2030.4962%2096.4179%2031.3656%2096.42%2032.273V52.168C95.5725%2051.9753%2094.7133%2051.8377%2093.848%2051.756V32.273C93.8479%2032.1606%2093.8256%2032.0494%2093.7824%2031.9457C93.7393%2031.8419%2093.6761%2031.7477%2093.5965%2031.6684C93.5169%2031.5891%2093.4225%2031.5262%2093.3186%2031.4834C93.2147%2031.4406%2093.1034%2031.4187%2092.991%2031.419H91.291V28.858L92.991%2028.859ZM77.701%2046.375C78.0421%2046.375%2078.3692%2046.5105%2078.6103%2046.7517C78.8515%2046.9928%2078.987%2047.3199%2078.987%2047.661C78.987%2048.0021%2078.8515%2048.3292%2078.6103%2048.5703C78.3692%2048.8115%2078.0421%2048.947%2077.701%2048.947H34.374C34.0329%2048.947%2033.7058%2048.8115%2033.4647%2048.5703C33.2235%2048.3292%2033.088%2048.0021%2033.088%2047.661C33.088%2047.3199%2033.2235%2046.9928%2033.4647%2046.7517C33.7058%2046.5105%2034.0329%2046.375%2034.374%2046.375H77.701ZM59.983%2037.801C60.3241%2037.801%2060.6512%2037.9365%2060.8923%2038.1777C61.1335%2038.4188%2061.269%2038.7459%2061.269%2039.087C61.269%2039.4281%2061.1335%2039.7552%2060.8923%2039.9963C60.6512%2040.2375%2060.3241%2040.373%2059.983%2040.373H34.374C34.0329%2040.373%2033.7058%2040.2375%2033.4647%2039.9963C33.2235%2039.7552%2033.088%2039.4281%2033.088%2039.087C33.088%2038.7459%2033.2235%2038.4188%2033.4647%2038.1777C33.7058%2037.9365%2034.0329%2037.801%2034.374%2037.801H59.983Z'%20fill='%238D9AA5'/%3e%3cpath%20fill-rule='evenodd'%20clip-rule='evenodd'%20d='M4%200C4.2066%200%204.40475%200.0820729%204.55084%200.228164C4.69693%200.374255%204.779%200.572397%204.779%200.779V3.221H7.221C7.41393%203.221%207.6%203.29258%207.74317%203.4219C7.88634%203.55122%207.97643%203.72907%207.996%203.921V4.001C7.996%204.2076%207.91393%204.40575%207.76784%204.55184C7.62175%204.69793%207.4236%204.78%207.217%204.78H4.779V7.222C4.779%207.41493%204.70742%207.601%204.5781%207.74417C4.44878%207.88734%204.27093%207.97744%204.079%207.997H3.999C3.7924%207.997%203.59425%207.91493%203.44816%207.76884C3.30207%207.62275%203.22%207.4246%203.22%207.218V4.779H0.779C0.585538%204.78002%200.398617%204.70902%200.254623%204.57981C0.110629%204.45061%200.0198653%204.27244%200%204.08V4C0%203.7934%200.082073%203.59526%200.228164%203.44916C0.374255%203.30307%200.572396%203.221%200.779%203.221H3.221V0.779C3.221%200.586071%203.29258%200.400004%203.4219%200.256831C3.55122%200.113658%203.72907%200.023565%203.921%200.00399971L4%200Z'%20fill='%238D9AA5'/%3e%3cpath%20d='M11%2099C11.5304%2099%2012.0391%2098.7893%2012.4142%2098.4142C12.7893%2098.0391%2013%2097.5304%2013%2097C13%2096.4696%2012.7893%2095.9609%2012.4142%2095.5858C12.0391%2095.2107%2011.5304%2095%2011%2095C10.4696%2095%209.96086%2095.2107%209.58579%2095.5858C9.21071%2095.9609%209%2096.4696%209%2097C9%2097.5304%209.21071%2098.0391%209.58579%2098.4142C9.96086%2098.7893%2010.4696%2099%2011%2099Z'%20fill='%238D9AA5'/%3e%3cpath%20d='M104.518%2015.035C103.055%2015.035%20101.651%2014.4538%20100.617%2013.4192C99.5817%2012.3846%2099.0003%2010.9813%2099%209.518C99%208.05454%2099.5814%206.65101%20100.616%205.61619C101.651%204.58136%20103.055%204%20104.518%204C105.981%204%20107.385%204.58136%20108.42%205.61619C109.455%206.65101%20110.036%208.05454%20110.036%209.518C110.036%2010.9813%20109.454%2012.3846%20108.419%2013.4192C107.385%2014.4538%20105.981%2015.035%20104.518%2015.035ZM104.518%2013.035C105.451%2013.035%20106.346%2012.6645%20107.005%2012.005C107.665%2011.3454%20108.036%2010.4509%20108.036%209.518C108.036%209.05601%20107.945%208.59854%20107.768%208.17172C107.591%207.7449%20107.332%207.35707%20107.006%207.0304C106.679%206.70372%20106.291%206.44459%20105.864%206.26779C105.437%206.091%20104.98%206%20104.518%206C103.585%206%20102.69%206.37065%20102.03%207.0304C101.371%207.69015%20101%208.58497%20101%209.518C101%2010.4509%20101.371%2011.3454%20102.031%2012.005C102.69%2012.6645%20103.585%2013.035%20104.518%2013.035Z'%20fill='%238D9AA5'/%3e%3c/svg%3e";
+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 j() {
+  return typeof window < "u" && "ontouchstart" in window;
+}
+function V(e) {
+  return "pointerId" in e ? null : e.type === "touchend" ? e.changedTouches : e.targetTouches;
+}
+function Y(e) {
+  return Array.from(V(e)).map((t) => t.identifier);
+}
+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 };
+}
+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 $() {
+}
+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 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 K(e, ...t) {
+  return typeof e == "function" ? e(...t) : e;
+}
+function _(e) {
+  return {
+    _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
+  };
+}
+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 ht({ config: e, windowListeners: t }, s, n = e.eventOptions) {
+  const r = w(e.window);
+  r && (b(r, t[s], n), delete t[s]);
+}
+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 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 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 B(e = []) {
+  return e.splice(0, e.length);
+}
+function p(e, t, s) {
+  e[t] || (e[t] = []), e[t].push(s);
+}
+function X(e, t = [], s = {}) {
+  if (e)
+    for (let [n, r] of t)
+      e.addEventListener(n, r, s);
+}
+function b(e, t = [], s = {}) {
+  if (e)
+    for (let [n, r] of t)
+      e.removeEventListener(n, r, s);
+}
+function x(e, t) {
+  return e.map((s, n) => s + t[n]);
+}
+function H(e, t) {
+  return e.map((s, n) => s - t[n]);
+}
+function C(e) {
+  return Math.hypot(...e);
+}
+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 };
+}
+function M(e) {
+  return Math.sign ? Math.sign(e) : +(e > 0) - +(e < 0) || +e;
+}
+function vt(e, t, s) {
+  return Math.max(t, Math.min(e, s));
+}
+function yt(e, t) {
+  return Math.pow(e, t * 5);
+}
+function z(e, t, s) {
+  return t === 0 || Math.abs(t) === 1 / 0 ? yt(e, s) : e * t * s / (t + s * e);
+}
+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;
+}
+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;
+      }
+      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
+  };
+  return {
+    ...c,
+    _initial: K(u, c),
+    _bounds: K(f, c)
+  };
+}
+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)
+      );
+    }
+    return n;
+  }
+  mapStateValues(t) {
+    return { xy: t.values, vxvy: t.velocities };
+  }
+}
+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();
+}
+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;
+      }
+      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);
+    }
+  }
+}
+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;
+    }
+    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 (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;
+    }
+    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;
+    }
+  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);
+    }
+  },
+  enabled(e = !0) {
+    return e;
+  },
+  triggerAllEvents(e = !1) {
+    return e;
+  },
+  initial(e = 0) {
+    return typeof e == "function" ? e : g(e);
+  },
+  transform: !0
+}, q = {
+  ...Kt,
+  axis: !0,
+  lockDirection(e = !1) {
+    return e;
+  },
+  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;
+  },
+  domTarget: !0,
+  window(e = zt ? window : void 0) {
+    return e;
+  },
+  eventOptions({ passive: e = !0, capture: t = !1 } = {}) {
+    return { passive: e, capture: t };
+  },
+  transform: !0
+}, Nt = {
+  ...q,
+  useTouch(e = !0) {
+    return e && j();
+  },
+  preventWindowScrollY(e = !1) {
+    return e;
+  },
+  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;
+  },
+  swipeVelocity(e = At) {
+    return g(e);
+  },
+  swipeDistance(e = Lt) {
+    return g(e);
+  },
+  swipeDuration(e = Gt) {
+    return e;
+  },
+  delay(e = 0) {
+    switch (e) {
+      case !0:
+        return Mt;
+      case !1:
+        return 0;
+      default:
+        return e;
+    }
+  }
+};
+function Wt(e) {
+  return k(
+    e,
+    Rt
+  );
+}
+function Ut(e = {}) {
+  return k(
+    e,
+    Nt
+  );
+}
+function jt({
+  domTarget: e,
+  eventOptions: t,
+  window: s,
+  enabled: n,
+  ...r
+}) {
+  const i = Wt({
+    domTarget: e,
+    eventOptions: t,
+    window: s,
+    enabled: n
+  });
+  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));
+}
 export {
-  C as default
+  x as addV,
+  R as rubberbandIfOutOfBounds,
+  H as subV,
+  Ft as useDrag
 };