@dmsi/wedgekit-react 1.0.1 → 2.0.1

package/dist/node_modules/@mikecousins/react-pdf/dist/index.js

@@ -0,0 +1,83 @@
+import { useState as I, useRef as n, useEffect as e } from "react";
+function i(f) {
+  return typeof f == "function";
+}
+const W = ({ canvasRef: f, file: j, onDocumentLoadSuccess: R, onDocumentLoadFail: d, onPageLoadSuccess: w, onPageLoadFail: h, onPageRenderSuccess: v, onPageRenderFail: x, scale: z = 1, rotate: m = 0, page: A = 1, cMapUrl: p, cMapPacked: B, workerSrc: D, withCredentials: G = !1 }) => {
+  const [o, J] = I(), [K, N] = I(), c = n(null), y = n(null), E = n(R), q = n(d), C = n(w), P = n(h), k = n(v), T = n(x);
+  return e(() => {
+    E.current = R;
+  }, [R]), e(() => {
+    q.current = d;
+  }, [d]), e(() => {
+    C.current = w;
+  }, [w]), e(() => {
+    P.current = h;
+  }, [h]), e(() => {
+    k.current = v;
+  }, [v]), e(() => {
+    T.current = x;
+  }, [x]), e(() => {
+    if (typeof window > "u") return;
+    const u = {
+      url: j,
+      withCredentials: G
+    };
+    p && (u.cMapUrl = p, u.cMapPacked = B), import("../../../pdfjs-dist/build/pdf.js").then(({ GlobalWorkerOptions: t, getDocument: V, version: s }) => {
+      t.workerSrc = D, V(u).promise.then((r) => {
+        J(r), i(E.current) && E.current(r);
+      }, () => {
+        i(q.current) && q.current();
+      });
+    });
+  }, [
+    j,
+    G,
+    p,
+    B,
+    D
+  ]), e(() => {
+    const u = (t) => {
+      const V = m === 0 ? t.rotate : t.rotate + m, s = t.getViewport({
+        scale: z,
+        rotation: V
+      }), r = f.current;
+      if (!r) return;
+      const b = r.getContext("2d");
+      if (!b) return;
+      const l = typeof window < "u" ? window.devicePixelRatio : 1;
+      if (r.height = s.height * l, r.width = s.width * l, b.scale(l, l), c.current) {
+        y.current = t, c.current.cancel();
+        return;
+      }
+      return c.current = t.render({
+        canvasContext: b,
+        canvas: r,
+        viewport: s
+      }), c.current.promise.then(() => {
+        c.current = null, i(k.current) && k.current(t);
+      }, (H) => {
+        if (c.current = null, H && H.name === "RenderingCancelledException") {
+          const O = y.current ?? t;
+          y.current = null, u(O);
+        } else i(T.current) && T.current();
+      });
+    };
+    o && o.getPage(A).then((t) => {
+      N(t), i(C.current) && C.current(t), u(t);
+    }, () => {
+      i(P.current) && P.current();
+    });
+  }, [
+    f,
+    A,
+    o,
+    m,
+    z
+  ]), {
+    pdfDocument: o,
+    pdfPage: K
+  };
+};
+export {
+  W as usePdf
+};

package/dist/node_modules/@react-aria/focus/dist/useFocusRing.js

@@ -0,0 +1,38 @@
+import { useFocus as V } from "../../interactions/dist/useFocus.js";
+import { isFocusVisible as r, useFocusVisibleListener as h } from "../../interactions/dist/useFocusVisible.js";
+import { useFocusWithin as x } from "../../interactions/dist/useFocusWithin.js";
+import { useRef as m, useState as a, useCallback as f } from "react";
+function I(n = {}) {
+  let { autoFocus: b = !1, isTextInput: u, within: i } = n, s = m({
+    isFocused: !1,
+    isFocusVisible: b || r()
+  }), [o, l] = a(!1), [d, F] = a(() => s.current.isFocused && s.current.isFocusVisible), t = f(() => F(s.current.isFocused && s.current.isFocusVisible), []), c = f((e) => {
+    s.current.isFocused = e, s.current.isFocusVisible = r(), l(e), t();
+  }, [
+    t
+  ]);
+  h((e) => {
+    s.current.isFocusVisible = e, t();
+  }, [
+    u,
+    o
+  ], {
+    enabled: o,
+    isTextInput: u
+  });
+  let { focusProps: p } = V({
+    isDisabled: i,
+    onFocusChange: c
+  }), { focusWithinProps: $ } = x({
+    isDisabled: !i,
+    onFocusWithinChange: c
+  });
+  return {
+    isFocused: o,
+    isFocusVisible: d,
+    focusProps: i ? $ : p
+  };
+}
+export {
+  I as useFocusRing
+};

package/dist/node_modules/@react-aria/interactions/dist/useFocus.js

@@ -0,0 +1,31 @@
+import { useSyntheticBlurEvent as m } from "./utils.js";
+import { useCallback as d } from "react";
+import { getEventTarget as a, getActiveElement as i } from "../../utils/dist/DOMFunctions.js";
+import { getOwnerDocument as b } from "../../utils/dist/domHelpers.js";
+function B($) {
+  let { isDisabled: c, onFocus: n, onBlur: t, onFocusChange: e } = $;
+  const f = d((o) => {
+    if (a(o) === o.currentTarget)
+      return t && t(o), e && e(!1), !0;
+  }, [
+    t,
+    e
+  ]), s = m(f), l = d((o) => {
+    let r = a(o);
+    const u = b(r), p = u ? i(u) : i();
+    r === o.currentTarget && r === p && (n && n(o), e && e(!0), s(o));
+  }, [
+    e,
+    n,
+    s
+  ]);
+  return {
+    focusProps: {
+      onFocus: !c && (n || e || t) ? l : void 0,
+      onBlur: !c && (t || e) ? f : void 0
+    }
+  };
+}
+export {
+  B as useFocus
+};

package/dist/node_modules/@react-aria/interactions/dist/useFocusVisible.js

@@ -0,0 +1,99 @@
+import { ignoreFocusEvent as h } from "./utils.js";
+import { getEventTarget as c, getActiveElement as H } from "../../utils/dist/DOMFunctions.js";
+import { getOwnerWindow as a, getOwnerDocument as $ } from "../../utils/dist/domHelpers.js";
+import { openLink as L } from "../../utils/dist/openLink.js";
+import { isMac as O } from "../../utils/dist/platform.js";
+import { isVirtualClick as F } from "../../utils/dist/isVirtualEvent.js";
+import { useEffect as I } from "react";
+let s = null;
+const l = /* @__PURE__ */ new Set();
+let u = /* @__PURE__ */ new Map(), i = !1, p = !1;
+const K = {
+  Tab: !0,
+  Escape: !0
+};
+function m(e, n) {
+  for (let t of l) t(e, n);
+}
+function C(e) {
+  return !(e.metaKey || !O() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+function b(e) {
+  i = !0, !L.isOpening && C(e) && (s = "keyboard", m("keyboard", e));
+}
+function o(e) {
+  s = "pointer", "pointerType" in e && e.pointerType, (e.type === "mousedown" || e.type === "pointerdown") && (i = !0, m("pointer", e));
+}
+function y(e) {
+  !L.isOpening && F(e) && (i = !0, s = "virtual");
+}
+function w(e) {
+  c(e) === window || c(e) === document || h || !e.isTrusted || (!i && !p && (s = "virtual", m("virtual", e)), i = !1, p = !1);
+}
+function T() {
+  i = !1, p = !0;
+}
+function E(e) {
+  if (typeof window > "u" || typeof document > "u" || u.get(a(e))) return;
+  const n = a(e), t = $(e);
+  let r = n.HTMLElement.prototype.focus;
+  n.HTMLElement.prototype.focus = function() {
+    i = !0, r.apply(this, arguments);
+  }, t.addEventListener("keydown", b, !0), t.addEventListener("keyup", b, !0), t.addEventListener("click", y, !0), n.addEventListener("focus", w, !0), n.addEventListener("blur", T, !1), typeof PointerEvent < "u" ? (t.addEventListener("pointerdown", o, !0), t.addEventListener("pointermove", o, !0), t.addEventListener("pointerup", o, !0)) : process.env.NODE_ENV === "test" && (t.addEventListener("mousedown", o, !0), t.addEventListener("mousemove", o, !0), t.addEventListener("mouseup", o, !0)), n.addEventListener("beforeunload", () => {
+    g(e);
+  }, {
+    once: !0
+  }), u.set(n, {
+    focus: r
+  });
+}
+const g = (e, n) => {
+  const t = a(e), r = $(e);
+  n && r.removeEventListener("DOMContentLoaded", n), u.has(t) && (t.HTMLElement.prototype.focus = u.get(t).focus, r.removeEventListener("keydown", b, !0), r.removeEventListener("keyup", b, !0), r.removeEventListener("click", y, !0), t.removeEventListener("focus", w, !0), t.removeEventListener("blur", T, !1), typeof PointerEvent < "u" ? (r.removeEventListener("pointerdown", o, !0), r.removeEventListener("pointermove", o, !0), r.removeEventListener("pointerup", o, !0)) : process.env.NODE_ENV === "test" && (r.removeEventListener("mousedown", o, !0), r.removeEventListener("mousemove", o, !0), r.removeEventListener("mouseup", o, !0)), u.delete(t));
+};
+function S(e) {
+  const n = $(e);
+  let t;
+  return n.readyState !== "loading" ? E(e) : (t = () => {
+    E(e);
+  }, n.addEventListener("DOMContentLoaded", t)), () => g(e, t);
+}
+typeof document < "u" && S();
+function V() {
+  return s !== "pointer";
+}
+const D = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+function j(e, n, t) {
+  let r = $(t ? c(t) : void 0), d = t ? c(t) : void 0;
+  const v = typeof window < "u" ? a(d).HTMLInputElement : HTMLInputElement, k = typeof window < "u" ? a(d).HTMLTextAreaElement : HTMLTextAreaElement, x = typeof window < "u" ? a(d).HTMLElement : HTMLElement, M = typeof window < "u" ? a(d).KeyboardEvent : KeyboardEvent;
+  let f = H(r);
+  return e = e || f instanceof v && !D.has(f.type) || f instanceof k || f instanceof x && f.isContentEditable, !(e && n === "keyboard" && t instanceof M && !K[t.key]);
+}
+function U(e, n, t) {
+  E(), I(() => {
+    if (t?.enabled === !1) return;
+    let r = (d, v) => {
+      j(!!t?.isTextInput, d, v) && e(V());
+    };
+    return l.add(r), () => {
+      l.delete(r);
+    };
+  }, n);
+}
+export {
+  S as addWindowFocusTracking,
+  l as changeHandlers,
+  u as hasSetupGlobalListeners,
+  V as isFocusVisible,
+  U as useFocusVisibleListener
+};

package/dist/node_modules/@react-aria/interactions/dist/useFocusWithin.js

@@ -0,0 +1,59 @@
+import { useSyntheticBlurEvent as x, setEventTarget as E, createSyntheticEvent as B } from "./utils.js";
+import { useRef as G, useCallback as p } from "react";
+import { nodeContains as i, getEventTarget as o, getActiveElement as L } from "../../utils/dist/DOMFunctions.js";
+import { getOwnerDocument as w } from "../../utils/dist/domHelpers.js";
+import { useGlobalListeners as C } from "../../utils/dist/useGlobalListeners.js";
+function k(g) {
+  let { isDisabled: m, onBlurWithin: c, onFocusWithin: s, onFocusWithinChange: t } = g, r = G({
+    isFocusWithin: !1
+  }), { addGlobalListener: u, removeAllGlobalListeners: l } = C(), n = p((e) => {
+    i(e.currentTarget, o(e)) && r.current.isFocusWithin && !i(e.currentTarget, e.relatedTarget) && (r.current.isFocusWithin = !1, l(), c && c(e), t && t(!1));
+  }, [
+    c,
+    t,
+    r,
+    l
+  ]), f = x(n), F = p((e) => {
+    if (!i(e.currentTarget, o(e))) return;
+    let d = o(e);
+    const a = w(d), W = L(a);
+    if (!r.current.isFocusWithin && W === d) {
+      s && s(e), t && t(!0), r.current.isFocusWithin = !0, f(e);
+      let $ = e.currentTarget;
+      u(a, "focus", (v) => {
+        let b = o(v);
+        if (r.current.isFocusWithin && !i($, b)) {
+          let h = new a.defaultView.FocusEvent("blur", {
+            relatedTarget: b
+          });
+          E(h, $);
+          let T = B(h);
+          n(T);
+        }
+      }, {
+        capture: !0
+      });
+    }
+  }, [
+    s,
+    t,
+    f,
+    u,
+    n
+  ]);
+  return m ? {
+    focusWithinProps: {
+      // These cannot be null, that would conflict in mergeProps
+      onFocus: void 0,
+      onBlur: void 0
+    }
+  } : {
+    focusWithinProps: {
+      onFocus: F,
+      onBlur: n
+    }
+  };
+}
+export {
+  k as useFocusWithin
+};

package/dist/node_modules/@react-aria/interactions/dist/useHover.js

@@ -0,0 +1,86 @@
+import { nodeContains as d, getEventTarget as a } from "../../utils/dist/DOMFunctions.js";
+import { getOwnerDocument as M } from "../../utils/dist/domHelpers.js";
+import { useGlobalListeners as G } from "../../utils/dist/useGlobalListeners.js";
+import { useState as x, useRef as D, useEffect as h, useMemo as N } from "react";
+let l = !1, f = 0;
+function c() {
+  l = !0, setTimeout(() => {
+    l = !1;
+  }, 50);
+}
+function T(v) {
+  v.pointerType === "touch" && c();
+}
+function S() {
+  if (!(typeof document > "u"))
+    return f === 0 && (typeof PointerEvent < "u" ? document.addEventListener("pointerup", T) : process.env.NODE_ENV === "test" && document.addEventListener("touchend", c)), f++, () => {
+      f--, !(f > 0) && (typeof PointerEvent < "u" ? document.removeEventListener("pointerup", T) : process.env.NODE_ENV === "test" && document.removeEventListener("touchend", c));
+    };
+}
+function A(v) {
+  let { onHoverStart: p, onHoverChange: s, onHoverEnd: g, isDisabled: r } = v, [y, $] = x(!1), t = D({
+    isHovered: !1,
+    ignoreEmulatedMouseEvents: !1,
+    pointerType: "",
+    target: null
+  }).current;
+  h(S, []);
+  let { addGlobalListener: m, removeAllGlobalListeners: b } = G(), { hoverProps: L, triggerHoverEnd: P } = N(() => {
+    let H = (e, n) => {
+      if (t.pointerType = n, r || n === "touch" || t.isHovered || !d(e.currentTarget, a(e))) return;
+      t.isHovered = !0;
+      let i = e.currentTarget;
+      t.target = i, m(M(a(e)), "pointerover", (E) => {
+        t.isHovered && t.target && !d(t.target, a(E)) && u(E, E.pointerType);
+      }, {
+        capture: !0
+      }), p && p({
+        type: "hoverstart",
+        target: i,
+        pointerType: n
+      }), s && s(!0), $(!0);
+    }, u = (e, n) => {
+      let i = t.target;
+      t.pointerType = "", t.target = null, !(n === "touch" || !t.isHovered || !i) && (t.isHovered = !1, b(), g && g({
+        type: "hoverend",
+        target: i,
+        pointerType: n
+      }), s && s(!1), $(!1));
+    }, o = {};
+    return typeof PointerEvent < "u" ? (o.onPointerEnter = (e) => {
+      l && e.pointerType === "mouse" || H(e, e.pointerType);
+    }, o.onPointerLeave = (e) => {
+      !r && d(e.currentTarget, a(e)) && u(e, e.pointerType);
+    }) : process.env.NODE_ENV === "test" && (o.onTouchStart = () => {
+      t.ignoreEmulatedMouseEvents = !0;
+    }, o.onMouseEnter = (e) => {
+      !t.ignoreEmulatedMouseEvents && !l && H(e, "mouse"), t.ignoreEmulatedMouseEvents = !1;
+    }, o.onMouseLeave = (e) => {
+      !r && d(e.currentTarget, a(e)) && u(e, "mouse");
+    }), {
+      hoverProps: o,
+      triggerHoverEnd: u
+    };
+  }, [
+    p,
+    s,
+    g,
+    r,
+    t,
+    m,
+    b
+  ]);
+  return h(() => {
+    r && P({
+      currentTarget: t.target
+    }, t.pointerType);
+  }, [
+    r
+  ]), {
+    hoverProps: L,
+    isHovered: y
+  };
+}
+export {
+  A as useHover
+};

package/dist/node_modules/@react-aria/interactions/dist/utils.js

@@ -0,0 +1,68 @@
+import { getEventTarget as u, getActiveElement as o } from "../../utils/dist/DOMFunctions.js";
+import { useLayoutEffect as l } from "../../utils/dist/useLayoutEffect.js";
+import { useRef as i, useCallback as b } from "react";
+function f(t) {
+  let e = t;
+  return e.nativeEvent = t, e.isDefaultPrevented = () => e.defaultPrevented, e.isPropagationStopped = () => e.cancelBubble, e.persist = () => {
+  }, e;
+}
+function E(t, e) {
+  Object.defineProperty(t, "target", {
+    value: e
+  }), Object.defineProperty(t, "currentTarget", {
+    value: e
+  });
+}
+function g(t) {
+  let e = i({
+    isFocused: !1,
+    observer: null
+  });
+  return l(() => {
+    const n = e.current;
+    return () => {
+      n.observer && (n.observer.disconnect(), n.observer = null);
+    };
+  }, []), b((n) => {
+    let c = u(n);
+    if (c instanceof HTMLButtonElement || c instanceof HTMLInputElement || c instanceof HTMLTextAreaElement || c instanceof HTMLSelectElement) {
+      e.current.isFocused = !0;
+      let r = c, d = (a) => {
+        if (e.current.isFocused = !1, r.disabled) {
+          let s = f(a);
+          t?.(s);
+        }
+        e.current.observer && (e.current.observer.disconnect(), e.current.observer = null);
+      };
+      r.addEventListener("focusout", d, {
+        once: !0
+      }), e.current.observer = new MutationObserver(() => {
+        if (e.current.isFocused && r.disabled) {
+          var a;
+          (a = e.current.observer) === null || a === void 0 || a.disconnect();
+          let s = r === o() ? null : o();
+          r.dispatchEvent(new FocusEvent("blur", {
+            relatedTarget: s
+          })), r.dispatchEvent(new FocusEvent("focusout", {
+            bubbles: !0,
+            relatedTarget: s
+          }));
+        }
+      }), e.current.observer.observe(r, {
+        attributes: !0,
+        attributeFilter: [
+          "disabled"
+        ]
+      });
+    }
+  }, [
+    t
+  ]);
+}
+let T = !1;
+export {
+  f as createSyntheticEvent,
+  T as ignoreFocusEvent,
+  E as setEventTarget,
+  g as useSyntheticBlurEvent
+};

package/dist/node_modules/@react-aria/utils/dist/DOMFunctions.js

@@ -0,0 +1,32 @@
+import { isShadowRoot as r } from "./domHelpers.js";
+import { shadowDOM as o } from "../../../@react-stately/flags/dist/import.js";
+function l(t, a) {
+  if (!o()) return a && t ? t.contains(a) : !1;
+  if (!t || !a) return !1;
+  let e = a;
+  for (; e !== null; ) {
+    if (e === t) return !0;
+    e.tagName === "SLOT" && e.assignedSlot ? e = e.assignedSlot.parentNode : r(e) ? e = e.host : e = e.parentNode;
+  }
+  return !1;
+}
+const n = (t = document) => {
+  var a;
+  if (!o()) return t.activeElement;
+  let e = t.activeElement;
+  for (; e && "shadowRoot" in e && (!((a = e.shadowRoot) === null || a === void 0) && a.activeElement); ) e = e.shadowRoot.activeElement;
+  return e;
+};
+function s(t) {
+  if (o() && t.target instanceof Element && t.target.shadowRoot) {
+    var a, e;
+    if ("composedPath" in t) return (a = t.composedPath()[0]) !== null && a !== void 0 ? a : null;
+    if ("composedPath" in t.nativeEvent) return (e = t.nativeEvent.composedPath()[0]) !== null && e !== void 0 ? e : null;
+  }
+  return t.target;
+}
+export {
+  n as getActiveElement,
+  s as getEventTarget,
+  l as nodeContains
+};

package/dist/node_modules/@react-aria/utils/dist/domHelpers.js

@@ -0,0 +1,15 @@
+const t = (o) => {
+  var n;
+  return (n = o?.ownerDocument) !== null && n !== void 0 ? n : document;
+}, e = (o) => o && "window" in o && o.window === o ? o : t(o).defaultView || window;
+function d(o) {
+  return o !== null && typeof o == "object" && "nodeType" in o && typeof o.nodeType == "number";
+}
+function c(o) {
+  return d(o) && o.nodeType === Node.DOCUMENT_FRAGMENT_NODE && "host" in o;
+}
+export {
+  t as getOwnerDocument,
+  e as getOwnerWindow,
+  c as isShadowRoot
+};

package/dist/node_modules/@react-aria/utils/dist/focusWithoutScrolling.js

@@ -0,0 +1,45 @@
+function f(l) {
+  if (c()) l.focus({
+    preventScroll: !0
+  });
+  else {
+    let e = n(l);
+    l.focus(), s(e);
+  }
+}
+let r = null;
+function c() {
+  if (r == null) {
+    r = !1;
+    try {
+      document.createElement("div").focus({
+        get preventScroll() {
+          return r = !0, !0;
+        }
+      });
+    } catch {
+    }
+  }
+  return r;
+}
+function n(l) {
+  let e = l.parentNode, o = [], t = document.scrollingElement || document.documentElement;
+  for (; e instanceof HTMLElement && e !== t; )
+    (e.offsetHeight < e.scrollHeight || e.offsetWidth < e.scrollWidth) && o.push({
+      element: e,
+      scrollTop: e.scrollTop,
+      scrollLeft: e.scrollLeft
+    }), e = e.parentNode;
+  return t instanceof HTMLElement && o.push({
+    element: t,
+    scrollTop: t.scrollTop,
+    scrollLeft: t.scrollLeft
+  }), o;
+}
+function s(l) {
+  for (let { element: e, scrollTop: o, scrollLeft: t } of l)
+    e.scrollTop = o, e.scrollLeft = t;
+}
+export {
+  f as focusWithoutScrolling
+};

package/dist/node_modules/@react-aria/utils/dist/isVirtualEvent.js

@@ -0,0 +1,7 @@
+import { isAndroid as i } from "./platform.js";
+function o(r) {
+  return r.pointerType === "" && r.isTrusted ? !0 : i() && r.pointerType ? r.type === "click" && r.buttons === 1 : r.detail === 0 && !r.pointerType;
+}
+export {
+  o as isVirtualClick
+};

package/dist/node_modules/@react-aria/utils/dist/openLink.js

@@ -0,0 +1,28 @@
+import { focusWithoutScrolling as f } from "./focusWithoutScrolling.js";
+import { isFirefox as p, isWebKit as K, isMac as l, isIPad as $ } from "./platform.js";
+import "react";
+function o(e, c, d = !0) {
+  var t, a;
+  let { metaKey: i, ctrlKey: n, altKey: s, shiftKey: r } = c;
+  p() && (!((a = window.event) === null || a === void 0 || (t = a.type) === null || t === void 0) && t.startsWith("key")) && e.target === "_blank" && (l() ? i = !0 : n = !0);
+  let y = K() && l() && !$() && process.env.NODE_ENV !== "test" ? new KeyboardEvent("keydown", {
+    keyIdentifier: "Enter",
+    metaKey: i,
+    ctrlKey: n,
+    altKey: s,
+    shiftKey: r
+  }) : new MouseEvent("click", {
+    metaKey: i,
+    ctrlKey: n,
+    altKey: s,
+    shiftKey: r,
+    detail: 1,
+    bubbles: !0,
+    cancelable: !0
+  });
+  o.isOpening = d, f(e), e.dispatchEvent(y), o.isOpening = !1;
+}
+o.isOpening = !1;
+export {
+  o as openLink
+};

package/dist/node_modules/@react-aria/utils/dist/platform.js

@@ -0,0 +1,47 @@
+function a(t) {
+  var n;
+  if (typeof window > "u" || window.navigator == null) return !1;
+  let o = (n = window.navigator.userAgentData) === null || n === void 0 ? void 0 : n.brands;
+  return Array.isArray(o) && o.some((s) => t.test(s.brand)) || t.test(window.navigator.userAgent);
+}
+function r(t) {
+  var n;
+  return typeof window < "u" && window.navigator != null ? t.test(((n = window.navigator.userAgentData) === null || n === void 0 ? void 0 : n.platform) || window.navigator.platform) : !1;
+}
+function e(t) {
+  if (process.env.NODE_ENV === "test") return t;
+  let n = null;
+  return () => (n == null && (n = t()), n);
+}
+const i = e(function() {
+  return r(/^Mac/i);
+}), c = e(function() {
+  return r(/^iPhone/i);
+}), u = e(function() {
+  return r(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+  i() && navigator.maxTouchPoints > 1;
+}), d = e(function() {
+  return c() || u();
+});
+e(function() {
+  return i() || d();
+});
+const f = e(function() {
+  return a(/AppleWebKit/i) && !$();
+}), $ = e(function() {
+  return a(/Chrome/i);
+}), l = e(function() {
+  return a(/Android/i);
+}), w = e(function() {
+  return a(/Firefox/i);
+});
+export {
+  l as isAndroid,
+  $ as isChrome,
+  w as isFirefox,
+  d as isIOS,
+  u as isIPad,
+  c as isIPhone,
+  i as isMac,
+  f as isWebKit
+};

package/dist/node_modules/@react-aria/utils/dist/useGlobalListeners.js

@@ -0,0 +1,34 @@
+import { useRef as c, useCallback as f, useEffect as b } from "react";
+function L() {
+  let o = c(/* @__PURE__ */ new Map()), u = f((e, l, r, t) => {
+    let n = t?.once ? (...d) => {
+      o.current.delete(r), r(...d);
+    } : r;
+    o.current.set(r, {
+      type: l,
+      eventTarget: e,
+      fn: n,
+      options: t
+    }), e.addEventListener(l, n, t);
+  }, []), a = f((e, l, r, t) => {
+    var n;
+    let d = ((n = o.current.get(r)) === null || n === void 0 ? void 0 : n.fn) || r;
+    e.removeEventListener(l, d, t), o.current.delete(r);
+  }, []), s = f(() => {
+    o.current.forEach((e, l) => {
+      a(e.eventTarget, e.type, l, e.options);
+    });
+  }, [
+    a
+  ]);
+  return b(() => s, [
+    s
+  ]), {
+    addGlobalListener: u,
+    removeGlobalListener: a,
+    removeAllGlobalListeners: s
+  };
+}
+export {
+  L as useGlobalListeners
+};