@lazar-ui/kit 0.1.0

package/dist/Overlay-RmiBtqDR.mjs

@@ -0,0 +1,1011 @@
+import v, { useRef as S, useCallback as de, useContext as M, useState as fe, useMemo as D, useEffect as $e, createContext as Ce } from "react";
+import _e from "react-dom";
+function J(e) {
+  if (Fe()) e.focus({
+    preventScroll: !0
+  });
+  else {
+    let t = Re(e);
+    e.focus(), Me(t);
+  }
+}
+let V = null;
+function Fe() {
+  if (V == null) {
+    V = !1;
+    try {
+      document.createElement("div").focus({
+        get preventScroll() {
+          return V = !0, !0;
+        }
+      });
+    } catch {
+    }
+  }
+  return V;
+}
+function Re(e) {
+  let t = e.parentNode, r = [], n = document.scrollingElement || document.documentElement;
+  for (; t instanceof HTMLElement && t !== n; )
+    (t.offsetHeight < t.scrollHeight || t.offsetWidth < t.scrollWidth) && r.push({
+      element: t,
+      scrollTop: t.scrollTop,
+      scrollLeft: t.scrollLeft
+    }), t = t.parentNode;
+  return n instanceof HTMLElement && r.push({
+    element: n,
+    scrollTop: n.scrollTop,
+    scrollLeft: n.scrollLeft
+  }), r;
+}
+function Me(e) {
+  for (let { element: t, scrollTop: r, scrollLeft: n } of e)
+    t.scrollTop = r, t.scrollLeft = n;
+}
+const h = (e) => e?.ownerDocument ?? document, R = (e) => e && "window" in e && e.window === e ? e : h(e).defaultView || window;
+function Oe(e) {
+  return e !== null && typeof e == "object" && "nodeType" in e && typeof e.nodeType == "number";
+}
+function De(e) {
+  return Oe(e) && e.nodeType === Node.DOCUMENT_FRAGMENT_NODE && "host" in e;
+}
+let Ae = !1;
+function U() {
+  return Ae;
+}
+function W(e, t) {
+  if (!U()) return t && e ? e.contains(t) : !1;
+  if (!e || !t) return !1;
+  let r = t;
+  for (; r !== null; ) {
+    if (r === e) return !0;
+    r.tagName === "SLOT" && r.assignedSlot ? r = r.assignedSlot.parentNode : De(r) ? r = r.host : r = r.parentNode;
+  }
+  return !1;
+}
+const w = (e = document) => {
+  if (!U()) return e.activeElement;
+  let t = e.activeElement;
+  for (; t && "shadowRoot" in t && t.shadowRoot?.activeElement; ) t = t.shadowRoot.activeElement;
+  return t;
+};
+function m(e) {
+  if (U() && e.target instanceof Element && e.target.shadowRoot) {
+    if ("composedPath" in e) return e.composedPath()[0] ?? null;
+    if ("composedPath" in e.nativeEvent) return e.nativeEvent.composedPath()[0] ?? null;
+  }
+  return e.target;
+}
+function Lt(e) {
+  if (!e) return !1;
+  let t = e.getRootNode(), r = R(e);
+  if (!(t instanceof r.Document || t instanceof r.ShadowRoot)) return !1;
+  let n = t.activeElement;
+  return n != null && e.contains(n);
+}
+const Pe = typeof Element < "u" && "checkVisibility" in Element.prototype;
+function Ke(e) {
+  const t = R(e);
+  if (!(e instanceof t.HTMLElement) && !(e instanceof t.SVGElement)) return !1;
+  let { display: r, visibility: n } = e.style, o = r !== "none" && n !== "hidden" && n !== "collapse";
+  if (o) {
+    const { getComputedStyle: i } = e.ownerDocument.defaultView;
+    let { display: c, visibility: a } = i(e);
+    o = c !== "none" && a !== "hidden" && a !== "collapse";
+  }
+  return o;
+}
+function Ie(e, t) {
+  return !e.hasAttribute("hidden") && // Ignore HiddenSelect when tree walking.
+  !e.hasAttribute("data-react-aria-prevent-focus") && (e.nodeName === "DETAILS" && t && t.nodeName !== "SUMMARY" ? e.hasAttribute("open") : !0);
+}
+function te(e, t) {
+  return Pe ? e.checkVisibility({
+    visibilityProperty: !0
+  }) && !e.closest("[data-react-aria-prevent-focus]") : e.nodeName !== "#comment" && Ke(e) && Ie(e, t) && (!e.parentElement || te(e.parentElement, e));
+}
+const re = [
+  "input:not([disabled]):not([type=hidden])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "button:not([disabled])",
+  "a[href]",
+  "area[href]",
+  "summary",
+  "iframe",
+  "object",
+  "embed",
+  "audio[controls]",
+  "video[controls]",
+  '[contenteditable]:not([contenteditable^="false"])',
+  "permission"
+], Ve = re.join(":not([hidden]),") + ",[tabindex]:not([disabled]):not([hidden])";
+re.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
+const We = re.join(':not([hidden]):not([tabindex="-1"]),');
+function He(e, t) {
+  return e.matches(Ve) && !be(e) && (t?.skipVisibilityCheck || te(e));
+}
+function je(e) {
+  return e.matches(We) && te(e) && !be(e);
+}
+function be(e) {
+  let t = e;
+  for (; t != null; ) {
+    if (t instanceof t.ownerDocument.defaultView.HTMLElement && t.inert) return !0;
+    t = t.parentElement;
+  }
+  return !1;
+}
+const N = typeof document < "u" ? v.useLayoutEffect : () => {
+};
+function Be(e) {
+  let t = e;
+  return t.nativeEvent = e, t.isDefaultPrevented = () => t.defaultPrevented, t.isPropagationStopped = () => t.cancelBubble, t.persist = () => {
+  }, t;
+}
+function kt(e, t) {
+  Object.defineProperty(e, "target", {
+    value: t
+  }), Object.defineProperty(e, "currentTarget", {
+    value: t
+  });
+}
+function Ct(e) {
+  let t = S({
+    isFocused: !1,
+    observer: null
+  });
+  return N(() => {
+    const r = t.current;
+    return () => {
+      r.observer && (r.observer.disconnect(), r.observer = null);
+    };
+  }, []), de((r) => {
+    let n = m(r);
+    if (n instanceof HTMLButtonElement || n instanceof HTMLInputElement || n instanceof HTMLTextAreaElement || n instanceof HTMLSelectElement) {
+      t.current.isFocused = !0;
+      let o = n, i = (c) => {
+        if (t.current.isFocused = !1, o.disabled) {
+          let a = Be(c);
+          e?.(a);
+        }
+        t.current.observer && (t.current.observer.disconnect(), t.current.observer = null);
+      };
+      o.addEventListener("focusout", i, {
+        once: !0
+      }), t.current.observer = new MutationObserver(() => {
+        if (t.current.isFocused && o.disabled) {
+          t.current.observer?.disconnect();
+          let c = o === w() ? null : w();
+          o.dispatchEvent(new FocusEvent("blur", {
+            relatedTarget: c
+          })), o.dispatchEvent(new FocusEvent("focusout", {
+            bubbles: !0,
+            relatedTarget: c
+          }));
+        }
+      }), t.current.observer.observe(o, {
+        attributes: !0,
+        attributeFilter: [
+          "disabled"
+        ]
+      });
+    }
+  }, [
+    e
+  ]);
+}
+let Ue = !1;
+function z(e) {
+  if (typeof window > "u" || window.navigator == null) return !1;
+  let t = window.navigator.userAgentData?.brands;
+  return Array.isArray(t) && t.some((r) => e.test(r.brand)) || e.test(window.navigator.userAgent);
+}
+function ne(e) {
+  return typeof window < "u" && window.navigator != null ? e.test(window.navigator.userAgentData?.platform || window.navigator.platform) : !1;
+}
+function x(e) {
+  if (process.env.NODE_ENV === "test") return e;
+  let t = null;
+  return () => (t == null && (t = e()), t);
+}
+const P = x(function() {
+  return ne(/^Mac/i);
+}), ze = x(function() {
+  return ne(/^iPhone/i);
+}), pe = x(function() {
+  return ne(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+  P() && navigator.maxTouchPoints > 1;
+}), Ge = x(function() {
+  return ze() || pe();
+});
+x(function() {
+  return P() || Ge();
+});
+const qe = x(function() {
+  return z(/AppleWebKit/i) && !ve();
+}), ve = x(function() {
+  return z(/Chrome/i);
+}), he = x(function() {
+  return z(/Android/i);
+}), Je = x(function() {
+  return z(/Firefox/i);
+});
+function Ye(e) {
+  return e.pointerType === "" && e.isTrusted ? !0 : he() && e.pointerType ? e.type === "click" && e.buttons === 1 : e.detail === 0 && !e.pointerType;
+}
+function K(e, t, r = !0) {
+  let { metaKey: n, ctrlKey: o, altKey: i, shiftKey: c } = t;
+  Je() && window.event?.type?.startsWith("key") && e.target === "_blank" && (P() ? n = !0 : o = !0);
+  let a = qe() && P() && !pe() && process.env.NODE_ENV !== "test" ? new KeyboardEvent("keydown", {
+    keyIdentifier: "Enter",
+    metaKey: n,
+    ctrlKey: o,
+    altKey: i,
+    shiftKey: c
+  }) : new MouseEvent("click", {
+    metaKey: n,
+    ctrlKey: o,
+    altKey: i,
+    shiftKey: c,
+    detail: 1,
+    bubbles: !0,
+    cancelable: !0
+  });
+  K.isOpening = r, J(e), e.dispatchEvent(a), K.isOpening = !1;
+}
+K.isOpening = !1;
+const H = {
+  prefix: String(Math.round(Math.random() * 1e10)),
+  current: 0
+}, Ee = /* @__PURE__ */ v.createContext(H), Xe = /* @__PURE__ */ v.createContext(!1);
+let Qe = !!(typeof window < "u" && window.document && window.document.createElement), q = /* @__PURE__ */ new WeakMap();
+function Ze(e = !1) {
+  let t = M(Ee), r = S(null);
+  if (r.current === null && !e) {
+    let n = v.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED?.ReactCurrentOwner?.current;
+    if (n) {
+      let o = q.get(n);
+      o == null ? q.set(n, {
+        id: t.current,
+        state: n.memoizedState
+      }) : n.memoizedState !== o.state && (t.current = o.id, q.delete(n));
+    }
+    r.current = ++t.current;
+  }
+  return r.current;
+}
+function et(e) {
+  let t = M(Ee);
+  t === H && !Qe && process.env.NODE_ENV !== "production" && console.warn("When server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.");
+  let r = Ze(!!e), n = t === H && process.env.NODE_ENV === "test" ? "react-aria" : `react-aria${t.prefix}`;
+  return e || `${n}-${r}`;
+}
+function tt(e) {
+  let t = v.useId(), [r] = fe(me()), n = r || process.env.NODE_ENV === "test" ? "react-aria" : `react-aria${H.prefix}`;
+  return e || `${n}-${t}`;
+}
+const _t = typeof v.useId == "function" ? tt : et;
+function rt() {
+  return !1;
+}
+function nt() {
+  return !0;
+}
+function ot(e) {
+  return () => {
+  };
+}
+function me() {
+  return typeof v.useSyncExternalStore == "function" ? v.useSyncExternalStore(ot, rt, nt) : M(Xe);
+}
+let I = null;
+const it = /* @__PURE__ */ new Set();
+let A = /* @__PURE__ */ new Map(), F = !1, Y = !1;
+function oe(e, t) {
+  for (let r of it) r(e, t);
+}
+function at(e) {
+  return !(e.metaKey || !P() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+function j(e) {
+  F = !0, !K.isOpening && at(e) && (I = "keyboard", oe("keyboard", e));
+}
+function y(e) {
+  I = "pointer", "pointerType" in e && e.pointerType, (e.type === "mousedown" || e.type === "pointerdown") && (F = !0, oe("pointer", e));
+}
+function Ne(e) {
+  !K.isOpening && Ye(e) && (F = !0, I = "virtual");
+}
+function we(e) {
+  let t = R(m(e)), r = h(m(e));
+  m(e) === t || m(e) === r || Ue || !e.isTrusted || (!F && !Y && (I = "virtual", oe("virtual", e)), F = !1, Y = !1);
+}
+function ye() {
+  F = !1, Y = !0;
+}
+function ae(e) {
+  if (typeof window > "u" || typeof document > "u") return;
+  const t = R(e), r = h(e);
+  if (A.get(t)) return;
+  let n = t.HTMLElement.prototype.focus;
+  t.HTMLElement.prototype.focus = function() {
+    F = !0, n.apply(this, arguments);
+  }, r.addEventListener("keydown", j, !0), r.addEventListener("keyup", j, !0), r.addEventListener("click", Ne, !0), t.addEventListener("focus", we, !0), t.addEventListener("blur", ye, !1), typeof PointerEvent < "u" ? (r.addEventListener("pointerdown", y, !0), r.addEventListener("pointermove", y, !0), r.addEventListener("pointerup", y, !0)) : process.env.NODE_ENV === "test" && (r.addEventListener("mousedown", y, !0), r.addEventListener("mousemove", y, !0), r.addEventListener("mouseup", y, !0)), t.addEventListener("beforeunload", () => {
+    Te(e);
+  }, {
+    once: !0
+  }), A.set(t, {
+    focus: n
+  });
+}
+const Te = (e, t) => {
+  const r = R(e), n = h(e);
+  t && n.removeEventListener("DOMContentLoaded", t), A.has(r) && (r.HTMLElement.prototype.focus = A.get(r).focus, n.removeEventListener("keydown", j, !0), n.removeEventListener("keyup", j, !0), n.removeEventListener("click", Ne, !0), r.removeEventListener("focus", we, !0), r.removeEventListener("blur", ye, !1), typeof PointerEvent < "u" ? (n.removeEventListener("pointerdown", y, !0), n.removeEventListener("pointermove", y, !0), n.removeEventListener("pointerup", y, !0)) : process.env.NODE_ENV === "test" && (n.removeEventListener("mousedown", y, !0), n.removeEventListener("mousemove", y, !0), n.removeEventListener("mouseup", y, !0)), A.delete(r));
+};
+function ct(e) {
+  const t = h(e);
+  let r;
+  return t.readyState !== "loading" ? ae(e) : (r = () => {
+    ae(e);
+  }, t.addEventListener("DOMContentLoaded", r)), () => Te(e, r);
+}
+typeof document < "u" && ct();
+function ge() {
+  return I;
+}
+let L = /* @__PURE__ */ new Map(), X = /* @__PURE__ */ new Set();
+function ce() {
+  if (typeof window > "u") return;
+  function e(n) {
+    return "propertyName" in n;
+  }
+  let t = (n) => {
+    let o = m(n);
+    if (!e(n) || !o) return;
+    let i = L.get(o);
+    i || (i = /* @__PURE__ */ new Set(), L.set(o, i), o.addEventListener("transitioncancel", r, {
+      once: !0
+    })), i.add(n.propertyName);
+  }, r = (n) => {
+    let o = m(n);
+    if (!e(n) || !o) return;
+    let i = L.get(o);
+    if (i && (i.delete(n.propertyName), i.size === 0 && (o.removeEventListener("transitioncancel", r), L.delete(o)), L.size === 0)) {
+      for (let c of X) c();
+      X.clear();
+    }
+  };
+  document.body.addEventListener("transitionrun", t), document.body.addEventListener("transitionend", r);
+}
+typeof document < "u" && (document.readyState !== "loading" ? ce() : document.addEventListener("DOMContentLoaded", ce));
+function st() {
+  for (const [e] of L)
+    "isConnected" in e && !e.isConnected && L.delete(e);
+}
+function ut(e) {
+  requestAnimationFrame(() => {
+    st(), L.size === 0 ? e() : X.add(e);
+  });
+}
+function lt(e) {
+  if (!e.isConnected) return;
+  const t = h(e);
+  if (ge() === "virtual") {
+    let r = w(t);
+    ut(() => {
+      const n = w(t);
+      (n === r || n === t.body) && e.isConnected && J(e);
+    });
+  } else J(e);
+}
+const dt = v.useInsertionEffect ?? N;
+function Ft(e) {
+  const t = S(null);
+  return dt(() => {
+    t.current = e;
+  }, [
+    e
+  ]), de((...r) => {
+    const n = t.current;
+    return n?.(...r);
+  }, []);
+}
+const Se = v.createContext({
+  register: () => {
+  }
+});
+Se.displayName = "PressResponderContext";
+class ft {
+  constructor(t, r, n, o) {
+    this._walkerStack = [], this._currentSetFor = /* @__PURE__ */ new Set(), this._acceptNode = (c) => {
+      if (c.nodeType === Node.ELEMENT_NODE) {
+        const a = c.shadowRoot;
+        if (a) {
+          const d = this._doc.createTreeWalker(a, this.whatToShow, {
+            acceptNode: this._acceptNode
+          });
+          return this._walkerStack.unshift(d), NodeFilter.FILTER_ACCEPT;
+        } else {
+          if (typeof this.filter == "function") return this.filter(c);
+          if (this.filter?.acceptNode) return this.filter.acceptNode(c);
+          if (this.filter === null) return NodeFilter.FILTER_ACCEPT;
+        }
+      }
+      return NodeFilter.FILTER_SKIP;
+    }, this._doc = t, this.root = r, this.filter = o ?? null, this.whatToShow = n ?? NodeFilter.SHOW_ALL, this._currentNode = r, this._walkerStack.unshift(t.createTreeWalker(r, n, this._acceptNode));
+    const i = r.shadowRoot;
+    if (i) {
+      const c = this._doc.createTreeWalker(i, this.whatToShow, {
+        acceptNode: this._acceptNode
+      });
+      this._walkerStack.unshift(c);
+    }
+  }
+  get currentNode() {
+    return this._currentNode;
+  }
+  set currentNode(t) {
+    if (!W(this.root, t)) throw new Error("Cannot set currentNode to a node that is not contained by the root node.");
+    const r = [];
+    let n = t, o = t;
+    for (this._currentNode = t; n && n !== this.root; ) if (n.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      const c = n, a = this._doc.createTreeWalker(c, this.whatToShow, {
+        acceptNode: this._acceptNode
+      });
+      r.push(a), a.currentNode = o, this._currentSetFor.add(a), n = o = c.host;
+    } else n = n.parentNode;
+    const i = this._doc.createTreeWalker(this.root, this.whatToShow, {
+      acceptNode: this._acceptNode
+    });
+    r.push(i), i.currentNode = o, this._currentSetFor.add(i), this._walkerStack = r;
+  }
+  get doc() {
+    return this._doc;
+  }
+  firstChild() {
+    let t = this.currentNode, r = this.nextNode();
+    return W(t, r) ? (r && (this.currentNode = r), r) : (this.currentNode = t, null);
+  }
+  lastChild() {
+    let r = this._walkerStack[0].lastChild();
+    return r && (this.currentNode = r), r;
+  }
+  nextNode() {
+    const t = this._walkerStack[0].nextNode();
+    if (t) {
+      if (t.shadowRoot) {
+        let n;
+        if (typeof this.filter == "function" ? n = this.filter(t) : this.filter?.acceptNode && (n = this.filter.acceptNode(t)), n === NodeFilter.FILTER_ACCEPT)
+          return this.currentNode = t, t;
+        let o = this.nextNode();
+        return o && (this.currentNode = o), o;
+      }
+      return t && (this.currentNode = t), t;
+    } else if (this._walkerStack.length > 1) {
+      this._walkerStack.shift();
+      let r = this.nextNode();
+      return r && (this.currentNode = r), r;
+    } else return null;
+  }
+  previousNode() {
+    const t = this._walkerStack[0];
+    if (t.currentNode === t.root) {
+      if (this._currentSetFor.has(t))
+        if (this._currentSetFor.delete(t), this._walkerStack.length > 1) {
+          this._walkerStack.shift();
+          let n = this.previousNode();
+          return n && (this.currentNode = n), n;
+        } else return null;
+      return null;
+    }
+    const r = t.previousNode();
+    if (r) {
+      if (r.shadowRoot) {
+        let o;
+        if (typeof this.filter == "function" ? o = this.filter(r) : this.filter?.acceptNode && (o = this.filter.acceptNode(r)), o === NodeFilter.FILTER_ACCEPT)
+          return r && (this.currentNode = r), r;
+        let i = this.lastChild();
+        return i && (this.currentNode = i), i;
+      }
+      return r && (this.currentNode = r), r;
+    } else if (this._walkerStack.length > 1) {
+      this._walkerStack.shift();
+      let n = this.previousNode();
+      return n && (this.currentNode = n), n;
+    } else return null;
+  }
+  /**
+   * @deprecated
+   */
+  nextSibling() {
+    return null;
+  }
+  /**
+   * @deprecated
+   */
+  previousSibling() {
+    return null;
+  }
+  /**
+   * @deprecated
+   */
+  parentNode() {
+    return null;
+  }
+}
+function $t(e, t, r, n) {
+  return U() ? new ft(e, t, r, n) : e.createTreeWalker(t, r, n);
+}
+const se = /* @__PURE__ */ v.createContext(null), Q = "react-aria-focus-scope-restore";
+let $ = null;
+function bt(e) {
+  let { children: t, contain: r, restoreFocus: n, autoFocus: o } = e, i = S(null), c = S(null), a = S([]), { parentNode: d } = M(se) || {}, s = D(() => new ee({
+    scopeRef: a
+  }), [
+    a
+  ]);
+  N(() => {
+    let f = d || p.root;
+    if (p.getTreeNode(f.scopeRef) && $ && !B($, f.scopeRef)) {
+      let b = p.getTreeNode($);
+      b && (f = b);
+    }
+    f.addChild(s), p.addNode(s);
+  }, [
+    s,
+    d
+  ]), N(() => {
+    let f = p.getTreeNode(a);
+    f && (f.contain = !!r);
+  }, [
+    r
+  ]), N(() => {
+    let f = i.current?.nextSibling, b = [], E = (G) => G.stopPropagation();
+    for (; f && f !== c.current; )
+      b.push(f), f.addEventListener(Q, E), f = f.nextSibling;
+    return a.current = b, () => {
+      for (let G of b) G.removeEventListener(Q, E);
+    };
+  }, [
+    t
+  ]), Nt(a, n, r), Et(a, r), wt(a, n, r), mt(a, o), $e(() => {
+    const f = w(h(a.current ? a.current[0] : void 0));
+    let b = null;
+    if (T(f, a.current)) {
+      for (let E of p.traverse()) E.scopeRef && T(f, E.scopeRef.current) && (b = E);
+      b === p.getTreeNode(a) && ($ = b.scopeRef);
+    }
+  }, [
+    a
+  ]), N(() => () => {
+    let f = p.getTreeNode(a)?.parent?.scopeRef ?? null;
+    (a === $ || B(a, $)) && (!f || p.getTreeNode(f)) && ($ = f), p.removeTreeNode(a);
+  }, [
+    a
+  ]);
+  let u = D(() => pt(a), []), l = D(() => ({
+    focusManager: u,
+    parentNode: s
+  }), [
+    s,
+    u
+  ]);
+  return /* @__PURE__ */ v.createElement(se.Provider, {
+    value: l
+  }, /* @__PURE__ */ v.createElement("span", {
+    "data-focus-scope-start": !0,
+    hidden: !0,
+    ref: i
+  }), t, /* @__PURE__ */ v.createElement("span", {
+    "data-focus-scope-end": !0,
+    hidden: !0,
+    ref: c
+  }));
+}
+function pt(e) {
+  return {
+    focusNext(t = {}) {
+      let r = e.current, { from: n, tabbable: o, wrap: i, accept: c } = t, a = n || w(h(r[0] ?? void 0)), d = r[0].previousElementSibling, s = _(r), u = C(s, {
+        tabbable: o,
+        accept: c
+      }, r);
+      u.currentNode = T(a, r) ? a : d;
+      let l = u.nextNode();
+      return !l && i && (u.currentNode = d, l = u.nextNode()), l && g(l, !0), l;
+    },
+    focusPrevious(t = {}) {
+      let r = e.current, { from: n, tabbable: o, wrap: i, accept: c } = t, a = n || w(h(r[0] ?? void 0)), d = r[r.length - 1].nextElementSibling, s = _(r), u = C(s, {
+        tabbable: o,
+        accept: c
+      }, r);
+      u.currentNode = T(a, r) ? a : d;
+      let l = u.previousNode();
+      return !l && i && (u.currentNode = d, l = u.previousNode()), l && g(l, !0), l;
+    },
+    focusFirst(t = {}) {
+      let r = e.current, { tabbable: n, accept: o } = t, i = _(r), c = C(i, {
+        tabbable: n,
+        accept: o
+      }, r);
+      c.currentNode = r[0].previousElementSibling;
+      let a = c.nextNode();
+      return a && g(a, !0), a;
+    },
+    focusLast(t = {}) {
+      let r = e.current, { tabbable: n, accept: o } = t, i = _(r), c = C(i, {
+        tabbable: n,
+        accept: o
+      }, r);
+      c.currentNode = r[r.length - 1].nextElementSibling;
+      let a = c.previousNode();
+      return a && g(a, !0), a;
+    }
+  };
+}
+function _(e) {
+  return e[0].parentElement;
+}
+function O(e) {
+  let t = p.getTreeNode($);
+  for (; t && t.scopeRef !== e; ) {
+    if (t.contain) return !1;
+    t = t.parent;
+  }
+  return !0;
+}
+function vt(e) {
+  if (!e.form)
+    return Array.from(h(e).querySelectorAll(`input[type="radio"][name="${CSS.escape(e.name)}"]`)).filter((n) => !n.form);
+  const t = e.form.elements.namedItem(e.name);
+  let r = R(e);
+  return t instanceof r.RadioNodeList ? Array.from(t).filter((n) => n instanceof r.HTMLInputElement) : t instanceof r.HTMLInputElement ? [
+    t
+  ] : [];
+}
+function ht(e) {
+  if (e.checked) return !0;
+  const t = vt(e);
+  return t.length > 0 && !t.some((r) => r.checked);
+}
+function Et(e, t) {
+  let r = S(void 0), n = S(void 0);
+  N(() => {
+    let o = e.current;
+    if (!t) {
+      n.current && (cancelAnimationFrame(n.current), n.current = void 0);
+      return;
+    }
+    const i = h(o ? o[0] : void 0);
+    let c = (s) => {
+      if (s.key !== "Tab" || s.altKey || s.ctrlKey || s.metaKey || !O(e) || s.isComposing) return;
+      let u = w(i), l = e.current;
+      if (!l || !T(u, l)) return;
+      let f = _(l), b = C(f, {
+        tabbable: !0
+      }, l);
+      if (!u) return;
+      b.currentNode = u;
+      let E = s.shiftKey ? b.previousNode() : b.nextNode();
+      E || (b.currentNode = s.shiftKey ? l[l.length - 1].nextElementSibling : l[0].previousElementSibling, E = s.shiftKey ? b.previousNode() : b.nextNode()), s.preventDefault(), E && (g(E, !0), E instanceof R(E).HTMLInputElement && E.select());
+    }, a = (s) => {
+      (!$ || B($, e)) && T(m(s), e.current) ? ($ = e, r.current = m(s)) : O(e) && !k(m(s), e) ? r.current ? r.current.focus() : $ && $.current && Z($.current) : O(e) && (r.current = m(s));
+    }, d = (s) => {
+      n.current && cancelAnimationFrame(n.current), n.current = requestAnimationFrame(() => {
+        let u = ge(), l = (u === "virtual" || u === null) && he() && ve(), f = w(i);
+        if (!l && f && O(e) && !k(f, e)) {
+          $ = e;
+          let b = m(s);
+          b && b.isConnected ? (r.current = b, r.current?.focus()) : $.current && Z($.current);
+        }
+      });
+    };
+    return i.addEventListener("keydown", c, !1), i.addEventListener("focusin", a, !1), o?.forEach((s) => s.addEventListener("focusin", a, !1)), o?.forEach((s) => s.addEventListener("focusout", d, !1)), () => {
+      i.removeEventListener("keydown", c, !1), i.removeEventListener("focusin", a, !1), o?.forEach((s) => s.removeEventListener("focusin", a, !1)), o?.forEach((s) => s.removeEventListener("focusout", d, !1));
+    };
+  }, [
+    e,
+    t
+  ]), N(() => () => {
+    n.current && cancelAnimationFrame(n.current);
+  }, [
+    n
+  ]);
+}
+function xe(e) {
+  return k(e);
+}
+function T(e, t) {
+  return !e || !t ? !1 : t.some((r) => W(r, e));
+}
+function k(e, t = null) {
+  if (e instanceof Element && e.closest("[data-react-aria-top-layer]")) return !0;
+  for (let { scopeRef: r } of p.traverse(p.getTreeNode(t)))
+    if (r && T(e, r.current)) return !0;
+  return !1;
+}
+function Rt(e) {
+  return k(e, $);
+}
+function B(e, t) {
+  let r = p.getTreeNode(t)?.parent;
+  for (; r; ) {
+    if (r.scopeRef === e) return !0;
+    r = r.parent;
+  }
+  return !1;
+}
+function g(e, t = !1) {
+  if (e != null && !t) try {
+    lt(e);
+  } catch {
+  }
+  else if (e != null) try {
+    e.focus();
+  } catch {
+  }
+}
+function Le(e, t = !0) {
+  let r = e[0].previousElementSibling, n = _(e), o = C(n, {
+    tabbable: t
+  }, e);
+  o.currentNode = r;
+  let i = o.nextNode();
+  return t && !i && (n = _(e), o = C(n, {
+    tabbable: !1
+  }, e), o.currentNode = r, i = o.nextNode()), i;
+}
+function Z(e, t = !0) {
+  g(Le(e, t));
+}
+function mt(e, t) {
+  const r = v.useRef(t);
+  $e(() => {
+    if (r.current) {
+      $ = e;
+      const n = h(e.current ? e.current[0] : void 0);
+      !T(w(n), $.current) && e.current && Z(e.current);
+    }
+    r.current = !1;
+  }, [
+    e
+  ]);
+}
+function Nt(e, t, r) {
+  N(() => {
+    if (t || r) return;
+    let n = e.current;
+    const o = h(n ? n[0] : void 0);
+    let i = (c) => {
+      let a = m(c);
+      T(a, e.current) ? $ = e : xe(a) || ($ = null);
+    };
+    return o.addEventListener("focusin", i, !1), n?.forEach((c) => c.addEventListener("focusin", i, !1)), () => {
+      o.removeEventListener("focusin", i, !1), n?.forEach((c) => c.removeEventListener("focusin", i, !1));
+    };
+  }, [
+    e,
+    t,
+    r
+  ]);
+}
+function ue(e) {
+  let t = p.getTreeNode($);
+  for (; t && t.scopeRef !== e; ) {
+    if (t.nodeToRestore) return !1;
+    t = t.parent;
+  }
+  return t?.scopeRef === e;
+}
+function wt(e, t, r) {
+  const n = S(typeof document < "u" ? w(h(e.current ? e.current[0] : void 0)) : null);
+  N(() => {
+    let o = e.current;
+    const i = h(o ? o[0] : void 0);
+    if (!t || r) return;
+    let c = () => {
+      (!$ || B($, e)) && T(w(i), e.current) && ($ = e);
+    };
+    return i.addEventListener("focusin", c, !1), o?.forEach((a) => a.addEventListener("focusin", c, !1)), () => {
+      i.removeEventListener("focusin", c, !1), o?.forEach((a) => a.removeEventListener("focusin", c, !1));
+    };
+  }, [
+    e,
+    r
+  ]), N(() => {
+    const o = h(e.current ? e.current[0] : void 0);
+    if (!t) return;
+    let i = (c) => {
+      if (c.key !== "Tab" || c.altKey || c.ctrlKey || c.metaKey || !O(e) || c.isComposing) return;
+      let a = o.activeElement;
+      if (!k(a, e) || !ue(e)) return;
+      let d = p.getTreeNode(e);
+      if (!d) return;
+      let s = d.nodeToRestore, u = C(o.body, {
+        tabbable: !0
+      });
+      u.currentNode = a;
+      let l = c.shiftKey ? u.previousNode() : u.nextNode();
+      if ((!s || !s.isConnected || s === o.body) && (s = void 0, d.nodeToRestore = void 0), (!l || !k(l, e)) && s) {
+        u.currentNode = s;
+        do
+          l = c.shiftKey ? u.previousNode() : u.nextNode();
+        while (k(l, e));
+        c.preventDefault(), c.stopPropagation(), l ? g(l, !0) : xe(s) ? g(s, !0) : a.blur();
+      }
+    };
+    return r || o.addEventListener("keydown", i, !0), () => {
+      r || o.removeEventListener("keydown", i, !0);
+    };
+  }, [
+    e,
+    t,
+    r
+  ]), N(() => {
+    const o = h(e.current ? e.current[0] : void 0);
+    if (!t) return;
+    let i = p.getTreeNode(e);
+    if (i)
+      return i.nodeToRestore = n.current ?? void 0, () => {
+        let c = p.getTreeNode(e);
+        if (!c) return;
+        let a = c.nodeToRestore, d = w(o);
+        if (t && a && (d && k(d, e) || d === o.body && ue(e))) {
+          let s = p.clone();
+          requestAnimationFrame(() => {
+            if (o.activeElement === o.body) {
+              let u = s.getTreeNode(e);
+              for (; u; ) {
+                if (u.nodeToRestore && u.nodeToRestore.isConnected) {
+                  le(u.nodeToRestore);
+                  return;
+                }
+                u = u.parent;
+              }
+              for (u = s.getTreeNode(e); u; ) {
+                if (u.scopeRef && u.scopeRef.current && p.getTreeNode(u.scopeRef)) {
+                  let l = Le(u.scopeRef.current, !0);
+                  le(l);
+                  return;
+                }
+                u = u.parent;
+              }
+            }
+          });
+        }
+      };
+  }, [
+    e,
+    t
+  ]);
+}
+function le(e) {
+  e.dispatchEvent(new CustomEvent(Q, {
+    bubbles: !0,
+    cancelable: !0
+  })) && g(e);
+}
+function C(e, t, r) {
+  let n = t?.tabbable ? je : He, o = e?.nodeType === Node.ELEMENT_NODE ? e : null, i = h(o), c = $t(i, e || i, NodeFilter.SHOW_ELEMENT, {
+    acceptNode(a) {
+      return W(t?.from, a) || t?.tabbable && a.tagName === "INPUT" && a.getAttribute("type") === "radio" && (!ht(a) || c.currentNode.tagName === "INPUT" && c.currentNode.type === "radio" && c.currentNode.name === a.name) ? NodeFilter.FILTER_REJECT : n(a) && (!r || T(a, r)) && (!t?.accept || t.accept(a)) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  return t?.from && (c.currentNode = t.from), c;
+}
+class ie {
+  constructor() {
+    this.fastMap = /* @__PURE__ */ new Map(), this.root = new ee({
+      scopeRef: null
+    }), this.fastMap.set(null, this.root);
+  }
+  get size() {
+    return this.fastMap.size;
+  }
+  getTreeNode(t) {
+    return this.fastMap.get(t);
+  }
+  addTreeNode(t, r, n) {
+    let o = this.fastMap.get(r ?? null);
+    if (!o) return;
+    let i = new ee({
+      scopeRef: t
+    });
+    o.addChild(i), i.parent = o, this.fastMap.set(t, i), n && (i.nodeToRestore = n);
+  }
+  addNode(t) {
+    this.fastMap.set(t.scopeRef, t);
+  }
+  removeTreeNode(t) {
+    if (t === null) return;
+    let r = this.fastMap.get(t);
+    if (!r) return;
+    let n = r.parent;
+    for (let i of this.traverse()) i !== r && r.nodeToRestore && i.nodeToRestore && r.scopeRef && r.scopeRef.current && T(i.nodeToRestore, r.scopeRef.current) && (i.nodeToRestore = r.nodeToRestore);
+    let o = r.children;
+    n && (n.removeChild(r), o.size > 0 && o.forEach((i) => n && n.addChild(i))), this.fastMap.delete(r.scopeRef);
+  }
+  // Pre Order Depth First
+  *traverse(t = this.root) {
+    if (t.scopeRef != null && (yield t), t.children.size > 0) for (let r of t.children) yield* this.traverse(r);
+  }
+  clone() {
+    let t = new ie();
+    for (let r of this.traverse()) t.addTreeNode(r.scopeRef, r.parent?.scopeRef ?? null, r.nodeToRestore);
+    return t;
+  }
+}
+class ee {
+  constructor(t) {
+    this.children = /* @__PURE__ */ new Set(), this.contain = !1, this.scopeRef = t.scopeRef;
+  }
+  addChild(t) {
+    this.children.add(t), t.parent = this;
+  }
+  removeChild(t) {
+    this.children.delete(t), t.parent = void 0;
+  }
+}
+let p = new ie();
+function yt({ children: e }) {
+  let t = D(() => ({
+    register: () => {
+    }
+  }), []);
+  return /* @__PURE__ */ v.createElement(Se.Provider, {
+    value: t
+  }, e);
+}
+const Tt = /* @__PURE__ */ Ce({});
+function gt() {
+  return M(Tt) ?? {};
+}
+const ke = /* @__PURE__ */ v.createContext(null);
+function Mt(e) {
+  let t = me(), { portalContainer: r = t ? null : document.body, isExiting: n } = e, [o, i] = fe(!1), c = D(() => ({
+    contain: o,
+    setContain: i
+  }), [
+    o,
+    i
+  ]), { getContainer: a } = gt();
+  if (!e.portalContainer && a && (r = a()), !r) return null;
+  let d = e.children;
+  return e.disableFocusManagement || (d = /* @__PURE__ */ v.createElement(bt, {
+    restoreFocus: !0,
+    contain: (e.shouldContainFocus || o) && !n
+  }, d)), d = /* @__PURE__ */ v.createElement(ke.Provider, {
+    value: c
+  }, /* @__PURE__ */ v.createElement(yt, null, d)), /* @__PURE__ */ _e.createPortal(d, r);
+}
+function Ot() {
+  let t = M(ke)?.setContain;
+  N(() => {
+    t?.(!0);
+  }, [
+    t
+  ]);
+}
+export {
+  W as $,
+  Lt as a,
+  w as b,
+  m as c,
+  qe as d,
+  Ge as e,
+  Rt as f,
+  $t as g,
+  U as h,
+  Be as i,
+  Ct as j,
+  kt as k,
+  N as l,
+  me as m,
+  _t as n,
+  h as o,
+  R as p,
+  Ot as q,
+  Mt as r,
+  lt as s,
+  Ft as t
+};