react-spring-carousel 3.0.0-beta078 → 3.0.0-beta080

package/dist/use-gesture-react.esm-9eb8841a.js

@@ -0,0 +1,1004 @@
+import I, { useRef as nt, useEffect as rt } from "react";
+const P = "RSC::Event";
+function qt() {
+  const s = nt(null);
+  function t(n) {
+    rt(() => {
+      s.current || (s.current = document.createElement("div"));
+      function r(i) {
+        n(i.detail);
+      }
+      if (s.current)
+        return s.current.addEventListener(P, r, !1), () => {
+          var i;
+          (i = s.current) == null || i.removeEventListener(P, r, !1);
+        };
+    }, [n]);
+  }
+  function e(n) {
+    if (s.current) {
+      const r = new CustomEvent(P, {
+        detail: n
+      });
+      s.current.dispatchEvent(r);
+    }
+  }
+  return {
+    useListenToCustomEvent: t,
+    emitEvent: e
+  };
+}
+function it(s, t, e) {
+  return Math.max(t, Math.min(s, e));
+}
+const d = {
+  toVector(s, t) {
+    return s === void 0 && (s = t), Array.isArray(s) ? s : [s, s];
+  },
+  add(s, t) {
+    return [s[0] + t[0], s[1] + t[1]];
+  },
+  sub(s, t) {
+    return [s[0] - t[0], s[1] - t[1]];
+  },
+  addTo(s, t) {
+    s[0] += t[0], s[1] += t[1];
+  },
+  subTo(s, t) {
+    s[0] -= t[0], s[1] -= t[1];
+  }
+};
+function M(s, t, e) {
+  return t === 0 || Math.abs(t) === 1 / 0 ? Math.pow(s, e * 5) : s * t * e / (t + e * s);
+}
+function N(s, t, e, n = 0.15) {
+  return n === 0 ? it(s, t, e) : s < t ? -M(t - s, e - t, n) + t : s > e ? +M(s - e, e - t, n) + e : s;
+}
+function ot(s, [t, e], [n, r]) {
+  const [[i, o], [c, f]] = s;
+  return [N(t, i, o, n), N(e, c, f, r)];
+}
+function at(s, t) {
+  if (typeof s != "object" || s === null)
+    return s;
+  var e = s[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(s, t || "default");
+    if (typeof n != "object")
+      return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(s);
+}
+function ct(s) {
+  var t = at(s, "string");
+  return typeof t == "symbol" ? t : String(t);
+}
+function l(s, t, e) {
+  return t = ct(t), t in s ? Object.defineProperty(s, t, {
+    value: e,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : s[t] = e, s;
+}
+function U(s, t) {
+  var e = Object.keys(s);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(s);
+    t && (n = n.filter(function(r) {
+      return Object.getOwnPropertyDescriptor(s, r).enumerable;
+    })), e.push.apply(e, n);
+  }
+  return e;
+}
+function u(s) {
+  for (var t = 1; t < arguments.length; t++) {
+    var e = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? U(Object(e), !0).forEach(function(n) {
+      l(s, n, e[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(s, Object.getOwnPropertyDescriptors(e)) : U(Object(e)).forEach(function(n) {
+      Object.defineProperty(s, n, Object.getOwnPropertyDescriptor(e, n));
+    });
+  }
+  return s;
+}
+const H = {
+  pointer: {
+    start: "down",
+    change: "move",
+    end: "up"
+  },
+  mouse: {
+    start: "down",
+    change: "move",
+    end: "up"
+  },
+  touch: {
+    start: "start",
+    change: "move",
+    end: "end"
+  },
+  gesture: {
+    start: "start",
+    change: "change",
+    end: "end"
+  }
+};
+function K(s) {
+  return s ? s[0].toUpperCase() + s.slice(1) : "";
+}
+const ut = ["enter", "leave"];
+function ft(s = !1, t) {
+  return s && !ut.includes(t);
+}
+function ht(s, t = "", e = !1) {
+  const n = H[s], r = n && n[t] || t;
+  return "on" + K(s) + K(r) + (ft(e, r) ? "Capture" : "");
+}
+const dt = ["gotpointercapture", "lostpointercapture"];
+function lt(s) {
+  let t = s.substring(2).toLowerCase();
+  const e = !!~t.indexOf("passive");
+  e && (t = t.replace("passive", ""));
+  const n = dt.includes(t) ? "capturecapture" : "capture", r = !!~t.indexOf(n);
+  return r && (t = t.replace("capture", "")), {
+    device: t,
+    capture: r,
+    passive: e
+  };
+}
+function pt(s, t = "") {
+  const e = H[s], n = e && e[t] || t;
+  return s + n;
+}
+function O(s) {
+  return "touches" in s;
+}
+function G(s) {
+  return O(s) ? "touch" : "pointerType" in s ? s.pointerType : "mouse";
+}
+function mt(s) {
+  return Array.from(s.touches).filter((t) => {
+    var e, n;
+    return t.target === s.currentTarget || ((e = s.currentTarget) === null || e === void 0 || (n = e.contains) === null || n === void 0 ? void 0 : n.call(e, t.target));
+  });
+}
+function gt(s) {
+  return s.type === "touchend" || s.type === "touchcancel" ? s.changedTouches : s.targetTouches;
+}
+function X(s) {
+  return O(s) ? gt(s)[0] : s;
+}
+function _t(s) {
+  return mt(s).map((t) => t.identifier);
+}
+function x(s) {
+  const t = X(s);
+  return O(s) ? t.identifier : t.pointerId;
+}
+function R(s) {
+  const t = X(s);
+  return [t.clientX, t.clientY];
+}
+function yt(s) {
+  const t = {};
+  if ("buttons" in s && (t.buttons = s.buttons), "shiftKey" in s) {
+    const {
+      shiftKey: e,
+      altKey: n,
+      metaKey: r,
+      ctrlKey: i
+    } = s;
+    Object.assign(t, {
+      shiftKey: e,
+      altKey: n,
+      metaKey: r,
+      ctrlKey: i
+    });
+  }
+  return t;
+}
+function k(s, ...t) {
+  return typeof s == "function" ? s(...t) : s;
+}
+function vt() {
+}
+function bt(...s) {
+  return s.length === 0 ? vt : s.length === 1 ? s[0] : function() {
+    let t;
+    for (const e of s)
+      t = e.apply(this, arguments) || t;
+    return t;
+  };
+}
+function V(s, t) {
+  return Object.assign({}, t, s || {});
+}
+const wt = 32;
+class Et {
+  constructor(t, e, n) {
+    this.ctrl = t, this.args = e, this.key = n, this.state || (this.state = {}, this.computeValues([0, 0]), this.computeInitial(), this.init && this.init(), this.reset());
+  }
+  get state() {
+    return this.ctrl.state[this.key];
+  }
+  set state(t) {
+    this.ctrl.state[this.key] = t;
+  }
+  get shared() {
+    return this.ctrl.state.shared;
+  }
+  get eventStore() {
+    return this.ctrl.gestureEventStores[this.key];
+  }
+  get timeoutStore() {
+    return this.ctrl.gestureTimeoutStores[this.key];
+  }
+  get config() {
+    return this.ctrl.config[this.key];
+  }
+  get sharedConfig() {
+    return this.ctrl.config.shared;
+  }
+  get handler() {
+    return this.ctrl.handlers[this.key];
+  }
+  reset() {
+    const {
+      state: t,
+      shared: e,
+      ingKey: n,
+      args: r
+    } = this;
+    e[n] = t._active = t.active = t._blocked = t._force = !1, t._step = [!1, !1], t.intentional = !1, t._movement = [0, 0], t._distance = [0, 0], t._direction = [0, 0], t._delta = [0, 0], t._bounds = [[-1 / 0, 1 / 0], [-1 / 0, 1 / 0]], t.args = r, t.axis = void 0, t.memo = void 0, t.elapsedTime = t.timeDelta = 0, t.direction = [0, 0], t.distance = [0, 0], t.overflow = [0, 0], t._movementBound = [!1, !1], t.velocity = [0, 0], t.movement = [0, 0], t.delta = [0, 0], t.timeStamp = 0;
+  }
+  start(t) {
+    const e = this.state, n = this.config;
+    e._active || (this.reset(), this.computeInitial(), e._active = !0, e.target = t.target, e.currentTarget = t.currentTarget, e.lastOffset = n.from ? k(n.from, e) : e.offset, e.offset = e.lastOffset, e.startTime = e.timeStamp = t.timeStamp);
+  }
+  computeValues(t) {
+    const e = this.state;
+    e._values = t, e.values = this.config.transform(t);
+  }
+  computeInitial() {
+    const t = this.state;
+    t._initial = t._values, t.initial = t.values;
+  }
+  compute(t) {
+    const {
+      state: e,
+      config: n,
+      shared: r
+    } = this;
+    e.args = this.args;
+    let i = 0;
+    if (t && (e.event = t, n.preventDefault && t.cancelable && e.event.preventDefault(), e.type = t.type, r.touches = this.ctrl.pointerIds.size || this.ctrl.touchIds.size, r.locked = !!document.pointerLockElement, Object.assign(r, yt(t)), r.down = r.pressed = r.buttons % 2 === 1 || r.touches > 0, i = t.timeStamp - e.timeStamp, e.timeStamp = t.timeStamp, e.elapsedTime = e.timeStamp - e.startTime), e._active) {
+      const _ = e._delta.map(Math.abs);
+      d.addTo(e._distance, _);
+    }
+    this.axisIntent && this.axisIntent(t);
+    const [o, c] = e._movement, [f, h] = n.threshold, {
+      _step: a,
+      values: g
+    } = e;
+    if (n.hasCustomTransform ? (a[0] === !1 && (a[0] = Math.abs(o) >= f && g[0]), a[1] === !1 && (a[1] = Math.abs(c) >= h && g[1])) : (a[0] === !1 && (a[0] = Math.abs(o) >= f && Math.sign(o) * f), a[1] === !1 && (a[1] = Math.abs(c) >= h && Math.sign(c) * h)), e.intentional = a[0] !== !1 || a[1] !== !1, !e.intentional)
+      return;
+    const p = [0, 0];
+    if (n.hasCustomTransform) {
+      const [_, st] = g;
+      p[0] = a[0] !== !1 ? _ - a[0] : 0, p[1] = a[1] !== !1 ? st - a[1] : 0;
+    } else
+      p[0] = a[0] !== !1 ? o - a[0] : 0, p[1] = a[1] !== !1 ? c - a[1] : 0;
+    this.restrictToAxis && !e._blocked && this.restrictToAxis(p);
+    const w = e.offset, E = e._active && !e._blocked || e.active;
+    E && (e.first = e._active && !e.active, e.last = !e._active && e.active, e.active = r[this.ingKey] = e._active, t && (e.first && ("bounds" in n && (e._bounds = k(n.bounds, e)), this.setup && this.setup()), e.movement = p, this.computeOffset()));
+    const [T, D] = e.offset, [[A, Q], [Z, tt]] = e._bounds;
+    e.overflow = [T < A ? -1 : T > Q ? 1 : 0, D < Z ? -1 : D > tt ? 1 : 0], e._movementBound[0] = e.overflow[0] ? e._movementBound[0] === !1 ? e._movement[0] : e._movementBound[0] : !1, e._movementBound[1] = e.overflow[1] ? e._movementBound[1] === !1 ? e._movement[1] : e._movementBound[1] : !1;
+    const et = e._active ? n.rubberband || [0, 0] : [0, 0];
+    if (e.offset = ot(e._bounds, e.offset, et), e.delta = d.sub(e.offset, w), this.computeMovement(), E && (!e.last || i > wt)) {
+      e.delta = d.sub(e.offset, w);
+      const _ = e.delta.map(Math.abs);
+      d.addTo(e.distance, _), e.direction = e.delta.map(Math.sign), e._direction = e._delta.map(Math.sign), !e.first && i > 0 && (e.velocity = [_[0] / i, _[1] / i], e.timeDelta = i);
+    }
+  }
+  emit() {
+    const t = this.state, e = this.shared, n = this.config;
+    if (t._active || this.clean(), (t._blocked || !t.intentional) && !t._force && !n.triggerAllEvents)
+      return;
+    const r = this.handler(u(u(u({}, e), t), {}, {
+      [this.aliasKey]: t.values
+    }));
+    r !== void 0 && (t.memo = r);
+  }
+  clean() {
+    this.eventStore.clean(), this.timeoutStore.clean();
+  }
+}
+function Tt([s, t], e) {
+  const n = Math.abs(s), r = Math.abs(t);
+  if (n > r && n > e)
+    return "x";
+  if (r > n && r > e)
+    return "y";
+}
+class Dt extends Et {
+  constructor(...t) {
+    super(...t), l(this, "aliasKey", "xy");
+  }
+  reset() {
+    super.reset(), this.state.axis = void 0;
+  }
+  init() {
+    this.state.offset = [0, 0], this.state.lastOffset = [0, 0];
+  }
+  computeOffset() {
+    this.state.offset = d.add(this.state.lastOffset, this.state.movement);
+  }
+  computeMovement() {
+    this.state.movement = d.sub(this.state.offset, this.state.lastOffset);
+  }
+  axisIntent(t) {
+    const e = this.state, n = this.config;
+    if (!e.axis && t) {
+      const r = typeof n.axisThreshold == "object" ? n.axisThreshold[G(t)] : n.axisThreshold;
+      e.axis = Tt(e._movement, r);
+    }
+    e._blocked = (n.lockDirection || !!n.axis) && !e.axis || !!n.axis && n.axis !== e.axis;
+  }
+  restrictToAxis(t) {
+    if (this.config.axis || this.config.lockDirection)
+      switch (this.state.axis) {
+        case "x":
+          t[1] = 0;
+          break;
+        case "y":
+          t[0] = 0;
+          break;
+      }
+  }
+}
+const j = (s) => s, B = 0.15, L = {
+  enabled(s = !0) {
+    return s;
+  },
+  eventOptions(s, t, e) {
+    return u(u({}, e.shared.eventOptions), s);
+  },
+  preventDefault(s = !1) {
+    return s;
+  },
+  triggerAllEvents(s = !1) {
+    return s;
+  },
+  rubberband(s = 0) {
+    switch (s) {
+      case !0:
+        return [B, B];
+      case !1:
+        return [0, 0];
+      default:
+        return d.toVector(s);
+    }
+  },
+  from(s) {
+    if (typeof s == "function")
+      return s;
+    if (s != null)
+      return d.toVector(s);
+  },
+  transform(s, t, e) {
+    const n = s || e.shared.transform;
+    if (this.hasCustomTransform = !!n, process.env.NODE_ENV === "development") {
+      const r = n || j;
+      return (i) => {
+        const o = r(i);
+        return (!isFinite(o[0]) || !isFinite(o[1])) && console.warn(`[@use-gesture]: config.transform() must produce a valid result, but it was: [${o[0]},${[1]}]`), o;
+      };
+    }
+    return n || j;
+  },
+  threshold(s) {
+    return d.toVector(s, 0);
+  }
+};
+process.env.NODE_ENV === "development" && Object.assign(L, {
+  domTarget(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `domTarget` option has been renamed to `target`.");
+    return NaN;
+  },
+  lockDirection(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `lockDirection` option has been merged with `axis`. Use it as in `{ axis: 'lock' }`");
+    return NaN;
+  },
+  initial(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `initial` option has been renamed to `from`.");
+    return NaN;
+  }
+});
+const St = 0, v = u(u({}, L), {}, {
+  axis(s, t, {
+    axis: e
+  }) {
+    if (this.lockDirection = e === "lock", !this.lockDirection)
+      return e;
+  },
+  axisThreshold(s = St) {
+    return s;
+  },
+  bounds(s = {}) {
+    if (typeof s == "function")
+      return (i) => v.bounds(s(i));
+    if ("current" in s)
+      return () => s.current;
+    if (typeof HTMLElement == "function" && s instanceof HTMLElement)
+      return s;
+    const {
+      left: t = -1 / 0,
+      right: e = 1 / 0,
+      top: n = -1 / 0,
+      bottom: r = 1 / 0
+    } = s;
+    return [[t, e], [n, r]];
+  }
+}), Y = {
+  ArrowRight: (s, t = 1) => [s * t, 0],
+  ArrowLeft: (s, t = 1) => [-1 * s * t, 0],
+  ArrowUp: (s, t = 1) => [0, -1 * s * t],
+  ArrowDown: (s, t = 1) => [0, s * t]
+};
+class kt extends Dt {
+  constructor(...t) {
+    super(...t), l(this, "ingKey", "dragging");
+  }
+  reset() {
+    super.reset();
+    const t = this.state;
+    t._pointerId = void 0, t._pointerActive = !1, t._keyboardActive = !1, t._preventScroll = !1, t._delayed = !1, t.swipe = [0, 0], t.tap = !1, t.canceled = !1, t.cancel = this.cancel.bind(this);
+  }
+  setup() {
+    const t = this.state;
+    if (t._bounds instanceof HTMLElement) {
+      const e = t._bounds.getBoundingClientRect(), n = t.currentTarget.getBoundingClientRect(), r = {
+        left: e.left - n.left + t.offset[0],
+        right: e.right - n.right + t.offset[0],
+        top: e.top - n.top + t.offset[1],
+        bottom: e.bottom - n.bottom + t.offset[1]
+      };
+      t._bounds = v.bounds(r);
+    }
+  }
+  cancel() {
+    const t = this.state;
+    t.canceled || (t.canceled = !0, t._active = !1, setTimeout(() => {
+      this.compute(), this.emit();
+    }, 0));
+  }
+  setActive() {
+    this.state._active = this.state._pointerActive || this.state._keyboardActive;
+  }
+  clean() {
+    this.pointerClean(), this.state._pointerActive = !1, this.state._keyboardActive = !1, super.clean();
+  }
+  pointerDown(t) {
+    const e = this.config, n = this.state;
+    if (t.buttons != null && (Array.isArray(e.pointerButtons) ? !e.pointerButtons.includes(t.buttons) : e.pointerButtons !== -1 && e.pointerButtons !== t.buttons))
+      return;
+    const r = this.ctrl.setEventIds(t);
+    e.pointerCapture && t.target.setPointerCapture(t.pointerId), !(r && r.size > 1 && n._pointerActive) && (this.start(t), this.setupPointer(t), n._pointerId = x(t), n._pointerActive = !0, this.computeValues(R(t)), this.computeInitial(), e.preventScrollAxis && G(t) !== "mouse" ? (n._active = !1, this.setupScrollPrevention(t)) : e.delay > 0 ? (this.setupDelayTrigger(t), e.triggerAllEvents && (this.compute(t), this.emit())) : this.startPointerDrag(t));
+  }
+  startPointerDrag(t) {
+    const e = this.state;
+    e._active = !0, e._preventScroll = !0, e._delayed = !1, this.compute(t), this.emit();
+  }
+  pointerMove(t) {
+    const e = this.state, n = this.config;
+    if (!e._pointerActive || e.type === t.type && t.timeStamp === e.timeStamp)
+      return;
+    const r = x(t);
+    if (e._pointerId !== void 0 && r !== e._pointerId)
+      return;
+    const i = R(t);
+    if (document.pointerLockElement === t.target ? e._delta = [t.movementX, t.movementY] : (e._delta = d.sub(i, e._values), this.computeValues(i)), d.addTo(e._movement, e._delta), this.compute(t), e._delayed && e.intentional) {
+      this.timeoutStore.remove("dragDelay"), e.active = !1, this.startPointerDrag(t);
+      return;
+    }
+    if (n.preventScrollAxis && !e._preventScroll)
+      if (e.axis)
+        if (e.axis === n.preventScrollAxis || n.preventScrollAxis === "xy") {
+          e._active = !1, this.clean();
+          return;
+        } else {
+          this.timeoutStore.remove("startPointerDrag"), this.startPointerDrag(t);
+          return;
+        }
+      else
+        return;
+    this.emit();
+  }
+  pointerUp(t) {
+    this.ctrl.setEventIds(t);
+    try {
+      this.config.pointerCapture && t.target.hasPointerCapture(t.pointerId) && t.target.releasePointerCapture(t.pointerId);
+    } catch {
+      process.env.NODE_ENV === "development" && console.warn("[@use-gesture]: If you see this message, it's likely that you're using an outdated version of `@react-three/fiber`. \n\nPlease upgrade to the latest version.");
+    }
+    const e = this.state, n = this.config;
+    if (!e._active || !e._pointerActive)
+      return;
+    const r = x(t);
+    if (e._pointerId !== void 0 && r !== e._pointerId)
+      return;
+    this.state._pointerActive = !1, this.setActive(), this.compute(t);
+    const [i, o] = e._distance;
+    if (e.tap = i <= n.tapsThreshold && o <= n.tapsThreshold, e.tap && n.filterTaps)
+      e._force = !0;
+    else {
+      const [c, f] = e._delta, [h, a] = e._movement, [g, p] = n.swipe.velocity, [w, E] = n.swipe.distance, T = n.swipe.duration;
+      if (e.elapsedTime < T) {
+        const D = Math.abs(c / e.timeDelta), A = Math.abs(f / e.timeDelta);
+        D > g && Math.abs(h) > w && (e.swipe[0] = Math.sign(c)), A > p && Math.abs(a) > E && (e.swipe[1] = Math.sign(f));
+      }
+    }
+    this.emit();
+  }
+  pointerClick(t) {
+    !this.state.tap && t.detail > 0 && (t.preventDefault(), t.stopPropagation());
+  }
+  setupPointer(t) {
+    const e = this.config, n = e.device;
+    if (process.env.NODE_ENV === "development")
+      try {
+        if (n === "pointer" && e.preventScrollDelay === void 0) {
+          const r = "uv" in t ? t.sourceEvent.currentTarget : t.currentTarget;
+          window.getComputedStyle(r).touchAction === "auto" && console.warn("[@use-gesture]: The drag target has its `touch-action` style property set to `auto`. It is recommended to add `touch-action: 'none'` so that the drag gesture behaves correctly on touch-enabled devices. For more information read this: https://use-gesture.netlify.app/docs/extras/#touch-action.\n\nThis message will only show in development mode. It won't appear in production. If this is intended, you can ignore it.", r);
+        }
+      } catch {
+      }
+    e.pointerLock && t.currentTarget.requestPointerLock(), e.pointerCapture || (this.eventStore.add(this.sharedConfig.window, n, "change", this.pointerMove.bind(this)), this.eventStore.add(this.sharedConfig.window, n, "end", this.pointerUp.bind(this)), this.eventStore.add(this.sharedConfig.window, n, "cancel", this.pointerUp.bind(this)));
+  }
+  pointerClean() {
+    this.config.pointerLock && document.pointerLockElement === this.state.currentTarget && document.exitPointerLock();
+  }
+  preventScroll(t) {
+    this.state._preventScroll && t.cancelable && t.preventDefault();
+  }
+  setupScrollPrevention(t) {
+    this.state._preventScroll = !1, Ot(t);
+    const e = this.eventStore.add(this.sharedConfig.window, "touch", "change", this.preventScroll.bind(this), {
+      passive: !1
+    });
+    this.eventStore.add(this.sharedConfig.window, "touch", "end", e), this.eventStore.add(this.sharedConfig.window, "touch", "cancel", e), this.timeoutStore.add("startPointerDrag", this.startPointerDrag.bind(this), this.config.preventScrollDelay, t);
+  }
+  setupDelayTrigger(t) {
+    this.state._delayed = !0, this.timeoutStore.add("dragDelay", () => {
+      this.state._step = [0, 0], this.startPointerDrag(t);
+    }, this.config.delay);
+  }
+  keyDown(t) {
+    const e = Y[t.key];
+    if (e) {
+      const n = this.state, r = t.shiftKey ? 10 : t.altKey ? 0.1 : 1;
+      this.start(t), n._delta = e(this.config.keyboardDisplacement, r), n._keyboardActive = !0, d.addTo(n._movement, n._delta), this.compute(t), this.emit();
+    }
+  }
+  keyUp(t) {
+    t.key in Y && (this.state._keyboardActive = !1, this.setActive(), this.compute(t), this.emit());
+  }
+  bind(t) {
+    const e = this.config.device;
+    t(e, "start", this.pointerDown.bind(this)), this.config.pointerCapture && (t(e, "change", this.pointerMove.bind(this)), t(e, "end", this.pointerUp.bind(this)), t(e, "cancel", this.pointerUp.bind(this)), t("lostPointerCapture", "", this.pointerUp.bind(this))), this.config.keys && (t("key", "down", this.keyDown.bind(this)), t("key", "up", this.keyUp.bind(this))), this.config.filterTaps && t("click", "", this.pointerClick.bind(this), {
+      capture: !0,
+      passive: !1
+    });
+  }
+}
+function Ot(s) {
+  "persist" in s && typeof s.persist == "function" && s.persist();
+}
+const b = typeof window < "u" && window.document && window.document.createElement;
+function At() {
+  return b && "ontouchstart" in window;
+}
+function W() {
+  return At() || b && window.navigator.maxTouchPoints > 1;
+}
+function It() {
+  return b && "onpointerdown" in window;
+}
+function Pt() {
+  return b && "exitPointerLock" in window.document;
+}
+function xt() {
+  try {
+    return "constructor" in GestureEvent;
+  } catch {
+    return !1;
+  }
+}
+const m = {
+  isBrowser: b,
+  gesture: xt(),
+  touch: W(),
+  touchscreen: W(),
+  pointer: It(),
+  pointerLock: Pt()
+}, Ct = 250, Lt = 180, Mt = 0.5, Nt = 50, Ut = 250, Kt = 10, F = {
+  mouse: 0,
+  touch: 0,
+  pen: 8
+}, z = u(u({}, v), {}, {
+  device(s, t, {
+    pointer: {
+      touch: e = !1,
+      lock: n = !1,
+      mouse: r = !1
+    } = {}
+  }) {
+    return this.pointerLock = n && m.pointerLock, m.touch && e ? "touch" : this.pointerLock ? "mouse" : m.pointer && !r ? "pointer" : m.touch ? "touch" : "mouse";
+  },
+  preventScrollAxis(s, t, {
+    preventScroll: e
+  }) {
+    if (this.preventScrollDelay = typeof e == "number" ? e : e || e === void 0 && s ? Ct : void 0, !(!m.touchscreen || e === !1))
+      return s || (e !== void 0 ? "y" : void 0);
+  },
+  pointerCapture(s, t, {
+    pointer: {
+      capture: e = !0,
+      buttons: n = 1,
+      keys: r = !0
+    } = {}
+  }) {
+    return this.pointerButtons = n, this.keys = r, !this.pointerLock && this.device === "pointer" && e;
+  },
+  threshold(s, t, {
+    filterTaps: e = !1,
+    tapsThreshold: n = 3,
+    axis: r = void 0
+  }) {
+    const i = d.toVector(s, e ? n : r ? 1 : 0);
+    return this.filterTaps = e, this.tapsThreshold = n, i;
+  },
+  swipe({
+    velocity: s = Mt,
+    distance: t = Nt,
+    duration: e = Ut
+  } = {}) {
+    return {
+      velocity: this.transform(d.toVector(s)),
+      distance: this.transform(d.toVector(t)),
+      duration: e
+    };
+  },
+  delay(s = 0) {
+    switch (s) {
+      case !0:
+        return Lt;
+      case !1:
+        return 0;
+      default:
+        return s;
+    }
+  },
+  axisThreshold(s) {
+    return s ? u(u({}, F), s) : F;
+  },
+  keyboardDisplacement(s = Kt) {
+    return s;
+  }
+});
+process.env.NODE_ENV === "development" && Object.assign(z, {
+  useTouch(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `useTouch` option has been renamed to `pointer.touch`. Use it as in `{ pointer: { touch: true } }`.");
+    return NaN;
+  },
+  experimental_preventWindowScrollY(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `experimental_preventWindowScrollY` option has been renamed to `preventScroll`.");
+    return NaN;
+  },
+  swipeVelocity(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `swipeVelocity` option has been renamed to `swipe.velocity`. Use it as in `{ swipe: { velocity: 0.5 } }`.");
+    return NaN;
+  },
+  swipeDistance(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `swipeDistance` option has been renamed to `swipe.distance`. Use it as in `{ swipe: { distance: 50 } }`.");
+    return NaN;
+  },
+  swipeDuration(s) {
+    if (s !== void 0)
+      throw Error("[@use-gesture]: `swipeDuration` option has been renamed to `swipe.duration`. Use it as in `{ swipe: { duration: 250 } }`.");
+    return NaN;
+  }
+});
+u(u({}, L), {}, {
+  device(s, t, {
+    shared: e,
+    pointer: {
+      touch: n = !1
+    } = {}
+  }) {
+    if (e.target && !m.touch && m.gesture)
+      return "gesture";
+    if (m.touch && n)
+      return "touch";
+    if (m.touchscreen) {
+      if (m.pointer)
+        return "pointer";
+      if (m.touch)
+        return "touch";
+    }
+  },
+  bounds(s, t, {
+    scaleBounds: e = {},
+    angleBounds: n = {}
+  }) {
+    const r = (o) => {
+      const c = V(k(e, o), {
+        min: -1 / 0,
+        max: 1 / 0
+      });
+      return [c.min, c.max];
+    }, i = (o) => {
+      const c = V(k(n, o), {
+        min: -1 / 0,
+        max: 1 / 0
+      });
+      return [c.min, c.max];
+    };
+    return typeof e != "function" && typeof n != "function" ? [r(), i()] : (o) => [r(o), i(o)];
+  },
+  threshold(s, t, e) {
+    return this.lockDirection = e.axis === "lock", d.toVector(s, this.lockDirection ? [0.1, 3] : 0);
+  },
+  modifierKey(s) {
+    return s === void 0 ? "ctrlKey" : s;
+  },
+  pinchOnWheel(s = !0) {
+    return s;
+  }
+});
+u(u({}, v), {}, {
+  mouseOnly: (s = !0) => s
+});
+u(u({}, v), {}, {
+  mouseOnly: (s = !0) => s
+});
+const q = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map();
+function Rt(s) {
+  q.set(s.key, s.engine), C.set(s.key, s.resolver);
+}
+const Vt = {
+  key: "drag",
+  engine: kt,
+  resolver: z
+};
+function jt(s, t) {
+  if (s == null)
+    return {};
+  var e = {}, n = Object.keys(s), r, i;
+  for (i = 0; i < n.length; i++)
+    r = n[i], !(t.indexOf(r) >= 0) && (e[r] = s[r]);
+  return e;
+}
+function Bt(s, t) {
+  if (s == null)
+    return {};
+  var e = jt(s, t), n, r;
+  if (Object.getOwnPropertySymbols) {
+    var i = Object.getOwnPropertySymbols(s);
+    for (r = 0; r < i.length; r++)
+      n = i[r], !(t.indexOf(n) >= 0) && Object.prototype.propertyIsEnumerable.call(s, n) && (e[n] = s[n]);
+  }
+  return e;
+}
+const Yt = {
+  target(s) {
+    if (s)
+      return () => "current" in s ? s.current : s;
+  },
+  enabled(s = !0) {
+    return s;
+  },
+  window(s = m.isBrowser ? window : void 0) {
+    return s;
+  },
+  eventOptions({
+    passive: s = !0,
+    capture: t = !1
+  } = {}) {
+    return {
+      passive: s,
+      capture: t
+    };
+  },
+  transform(s) {
+    return s;
+  }
+}, Wt = ["target", "eventOptions", "window", "enabled", "transform"];
+function S(s = {}, t) {
+  const e = {};
+  for (const [n, r] of Object.entries(t))
+    switch (typeof r) {
+      case "function":
+        if (process.env.NODE_ENV === "development") {
+          const i = r.call(e, s[n], n, s);
+          Number.isNaN(i) || (e[n] = i);
+        } else
+          e[n] = r.call(e, s[n], n, s);
+        break;
+      case "object":
+        e[n] = S(s[n], r);
+        break;
+      case "boolean":
+        r && (e[n] = s[n]);
+        break;
+    }
+  return e;
+}
+function Ft(s, t, e = {}) {
+  const n = s, {
+    target: r,
+    eventOptions: i,
+    window: o,
+    enabled: c,
+    transform: f
+  } = n, h = Bt(n, Wt);
+  if (e.shared = S({
+    target: r,
+    eventOptions: i,
+    window: o,
+    enabled: c,
+    transform: f
+  }, Yt), t) {
+    const a = C.get(t);
+    e[t] = S(u({
+      shared: e.shared
+    }, h), a);
+  } else
+    for (const a in h) {
+      const g = C.get(a);
+      if (g)
+        e[a] = S(u({
+          shared: e.shared
+        }, h[a]), g);
+      else if (process.env.NODE_ENV === "development" && !["drag", "pinch", "scroll", "wheel", "move", "hover"].includes(a)) {
+        if (a === "domTarget")
+          throw Error("[@use-gesture]: `domTarget` option has been renamed to `target`.");
+        console.warn(`[@use-gesture]: Unknown config key \`${a}\` was used. Please read the documentation for further information.`);
+      }
+    }
+  return e;
+}
+class J {
+  constructor(t, e) {
+    l(this, "_listeners", /* @__PURE__ */ new Set()), this._ctrl = t, this._gestureKey = e;
+  }
+  add(t, e, n, r, i) {
+    const o = this._listeners, c = pt(e, n), f = this._gestureKey ? this._ctrl.config[this._gestureKey].eventOptions : {}, h = u(u({}, f), i);
+    t.addEventListener(c, r, h);
+    const a = () => {
+      t.removeEventListener(c, r, h), o.delete(a);
+    };
+    return o.add(a), a;
+  }
+  clean() {
+    this._listeners.forEach((t) => t()), this._listeners.clear();
+  }
+}
+class $t {
+  constructor() {
+    l(this, "_timeouts", /* @__PURE__ */ new Map());
+  }
+  add(t, e, n = 140, ...r) {
+    this.remove(t), this._timeouts.set(t, window.setTimeout(e, n, ...r));
+  }
+  remove(t) {
+    const e = this._timeouts.get(t);
+    e && window.clearTimeout(e);
+  }
+  clean() {
+    this._timeouts.forEach((t) => void window.clearTimeout(t)), this._timeouts.clear();
+  }
+}
+class Ht {
+  constructor(t) {
+    l(this, "gestures", /* @__PURE__ */ new Set()), l(this, "_targetEventStore", new J(this)), l(this, "gestureEventStores", {}), l(this, "gestureTimeoutStores", {}), l(this, "handlers", {}), l(this, "config", {}), l(this, "pointerIds", /* @__PURE__ */ new Set()), l(this, "touchIds", /* @__PURE__ */ new Set()), l(this, "state", {
+      shared: {
+        shiftKey: !1,
+        metaKey: !1,
+        ctrlKey: !1,
+        altKey: !1
+      }
+    }), Gt(this, t);
+  }
+  setEventIds(t) {
+    if (O(t))
+      return this.touchIds = new Set(_t(t)), this.touchIds;
+    if ("pointerId" in t)
+      return t.type === "pointerup" || t.type === "pointercancel" ? this.pointerIds.delete(t.pointerId) : t.type === "pointerdown" && this.pointerIds.add(t.pointerId), this.pointerIds;
+  }
+  applyHandlers(t, e) {
+    this.handlers = t, this.nativeHandlers = e;
+  }
+  applyConfig(t, e) {
+    this.config = Ft(t, e, this.config);
+  }
+  clean() {
+    this._targetEventStore.clean();
+    for (const t of this.gestures)
+      this.gestureEventStores[t].clean(), this.gestureTimeoutStores[t].clean();
+  }
+  effect() {
+    return this.config.shared.target && this.bind(), () => this._targetEventStore.clean();
+  }
+  bind(...t) {
+    const e = this.config.shared, n = {};
+    let r;
+    if (!(e.target && (r = e.target(), !r))) {
+      if (e.enabled) {
+        for (const o of this.gestures) {
+          const c = this.config[o], f = $(n, c.eventOptions, !!r);
+          if (c.enabled) {
+            const h = q.get(o);
+            new h(this, t, o).bind(f);
+          }
+        }
+        const i = $(n, e.eventOptions, !!r);
+        for (const o in this.nativeHandlers)
+          i(o, "", (c) => this.nativeHandlers[o](u(u({}, this.state.shared), {}, {
+            event: c,
+            args: t
+          })), void 0, !0);
+      }
+      for (const i in n)
+        n[i] = bt(...n[i]);
+      if (!r)
+        return n;
+      for (const i in n) {
+        const {
+          device: o,
+          capture: c,
+          passive: f
+        } = lt(i);
+        this._targetEventStore.add(r, o, "", n[i], {
+          capture: c,
+          passive: f
+        });
+      }
+    }
+  }
+}
+function y(s, t) {
+  s.gestures.add(t), s.gestureEventStores[t] = new J(s, t), s.gestureTimeoutStores[t] = new $t();
+}
+function Gt(s, t) {
+  t.drag && y(s, "drag"), t.wheel && y(s, "wheel"), t.scroll && y(s, "scroll"), t.move && y(s, "move"), t.pinch && y(s, "pinch"), t.hover && y(s, "hover");
+}
+const $ = (s, t, e) => (n, r, i, o = {}, c = !1) => {
+  var f, h;
+  const a = (f = o.capture) !== null && f !== void 0 ? f : t.capture, g = (h = o.passive) !== null && h !== void 0 ? h : t.passive;
+  let p = c ? n : ht(n, r, a);
+  e && g && (p += "Passive"), s[p] = s[p] || [], s[p].push(i);
+};
+function Xt(s, t = {}, e, n) {
+  const r = I.useMemo(() => new Ht(s), []);
+  if (r.applyHandlers(s, n), r.applyConfig(t, e), I.useEffect(r.effect.bind(r)), I.useEffect(() => r.clean.bind(r), []), t.target === void 0)
+    return r.bind.bind(r);
+}
+function Jt(s, t) {
+  return Rt(Vt), Xt({
+    drag: s
+  }, t || {}, "drag");
+}
+export {
+  Jt as a,
+  qt as u
+};