@commercetools/nimbus 0.0.12-rc1 → 0.0.12-rc3

package/dist/chunks/SelectionManager-CLyu96pU.es.js

@@ -0,0 +1,1946 @@
+import $, { useRef as E, useEffect as Y, useMemo as B, createContext as z, cloneElement as ze, forwardRef as He, useContext as _, useCallback as X, useState as ie, isValidElement as st } from "react";
+import { a as Ue, d as _e } from "./utils-jpfA6kxk.es.js";
+import { c as me, $ as J, a as qe, d as we, e as ot } from "./mergeProps-B_9syxhT.es.js";
+import { $ as be } from "./focusWithoutScrolling-CDw3JYiq.es.js";
+import { $ as Ge, d as ut } from "./openLink-Ctl0AdAy.es.js";
+import { $ as ee } from "./useEvent-YHhqZvpU.es.js";
+import { a as at, b as ct, c as Ce, d as De } from "./scrollIntoView-BYF_8_6g.es.js";
+import { b as dt } from "./FocusScope-CNO0fzPs.es.js";
+import { b as Ee } from "./useFocusVisible-CWDaG0ze.es.js";
+import { $ as Se } from "./focusSafely-DJpphVHF.es.js";
+import { flushSync as ft, createPortal as ht } from "react-dom";
+import { $ as yt } from "./context-R4YUlO9Y.es.js";
+import { b as pt, g as vt } from "./platform-Z5fvtFmM.es.js";
+import { $ as We } from "./usePress-DHhWHfMz.es.js";
+import { $ as gt } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { a as mt } from "./Hidden-j3Lbt7xL.es.js";
+import { b as ke } from "./useFocusable-CrsD8ZcF.es.js";
+import { $ as je } from "./SSRProvider-Cu8KibIK.es.js";
+import { $ as bt } from "./useControlledState-u436Wbp1.es.js";
+function Ie(n, e) {
+  const t = E(!0), i = E(null);
+  me(() => (t.current = !0, () => {
+    t.current = !1;
+  }), []), me(() => {
+    t.current ? t.current = !1 : (!i.current || e.some((l, r) => !Object.is(l, i[r]))) && n(), i.current = e;
+  }, e);
+}
+const St = "react-aria-clear-focus", $t = "react-aria-focus";
+function q(n) {
+  return pt() ? n.metaKey : n.ctrlKey;
+}
+const Kt = 500;
+function xt(n) {
+  let { isDisabled: e, onLongPressStart: t, onLongPressEnd: i, onLongPress: l, threshold: r = Kt, accessibilityDescription: s } = n;
+  const c = E(void 0);
+  let { addGlobalListener: u, removeGlobalListener: h } = gt(), { pressProps: b } = We({
+    isDisabled: e,
+    onPressStart(f) {
+      if (f.continuePropagation(), (f.pointerType === "mouse" || f.pointerType === "touch") && (t && t({
+        ...f,
+        type: "longpressstart"
+      }), c.current = setTimeout(() => {
+        f.target.dispatchEvent(new PointerEvent("pointercancel", {
+          bubbles: !0
+        })), Ue(f.target).activeElement !== f.target && be(f.target), l && l({
+          ...f,
+          type: "longpress"
+        }), c.current = void 0;
+      }, r), f.pointerType === "touch")) {
+        let y = (v) => {
+          v.preventDefault();
+        };
+        u(f.target, "contextmenu", y, {
+          once: !0
+        }), u(window, "pointerup", () => {
+          setTimeout(() => {
+            h(f.target, "contextmenu", y);
+          }, 30);
+        }, {
+          once: !0
+        });
+      }
+    },
+    onPressEnd(f) {
+      c.current && clearTimeout(c.current), i && (f.pointerType === "mouse" || f.pointerType === "touch") && i({
+        ...f,
+        type: "longpressend"
+      });
+    }
+  }), d = at(l && !e ? s : void 0);
+  return {
+    longPressProps: J(b, d)
+  };
+}
+function Ye(n) {
+  let e = Ct(Ue(n));
+  e !== n && (e && wt(e, n), n && Xe(n, e));
+}
+function wt(n, e) {
+  n.dispatchEvent(new FocusEvent("blur", {
+    relatedTarget: e
+  })), n.dispatchEvent(new FocusEvent("focusout", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function Xe(n, e) {
+  n.dispatchEvent(new FocusEvent("focus", {
+    relatedTarget: e
+  })), n.dispatchEvent(new FocusEvent("focusin", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function Ct(n) {
+  let e = _e(n), t = e?.getAttribute("aria-activedescendant");
+  return t && n.getElementById(t) || e;
+}
+function $e(n) {
+  return vt() ? n.altKey : n.ctrlKey;
+}
+function le(n, e) {
+  var t, i;
+  let l = `[data-key="${CSS.escape(String(e))}"]`, r = (t = n.current) === null || t === void 0 ? void 0 : t.dataset.collection;
+  return r && (l = `[data-collection="${CSS.escape(r)}"]${l}`), (i = n.current) === null || i === void 0 ? void 0 : i.querySelector(l);
+}
+const Je = /* @__PURE__ */ new WeakMap();
+function Dt(n) {
+  let e = qe();
+  return Je.set(n, e), e;
+}
+function Et(n) {
+  return Je.get(n);
+}
+const kt = 1e3;
+function It(n) {
+  let { keyboardDelegate: e, selectionManager: t, onTypeSelect: i } = n, l = E({
+    search: "",
+    timeout: void 0
+  }).current, r = (s) => {
+    let c = Pt(s.key);
+    if (!(!c || s.ctrlKey || s.metaKey || !s.currentTarget.contains(s.target) || l.search.length === 0 && c === " ")) {
+      if (c === " " && l.search.trim().length > 0 && (s.preventDefault(), "continuePropagation" in s || s.stopPropagation()), l.search += c, e.getKeyForSearch != null) {
+        let u = e.getKeyForSearch(l.search, t.focusedKey);
+        u == null && (u = e.getKeyForSearch(l.search)), u != null && (t.setFocusedKey(u), i && i(u));
+      }
+      clearTimeout(l.timeout), l.timeout = setTimeout(() => {
+        l.search = "";
+      }, kt);
+    }
+  };
+  return {
+    typeSelectProps: {
+      // Using a capturing listener to catch the keydown event before
+      // other hooks in order to handle the Spacebar event.
+      onKeyDownCapture: e.getKeyForSearch ? r : void 0
+    }
+  };
+}
+function Pt(n) {
+  return n.length === 1 || !/^[A-Z]/i.test(n) ? n : "";
+}
+function Si(n) {
+  let { selectionManager: e, keyboardDelegate: t, ref: i, autoFocus: l = !1, shouldFocusWrap: r = !1, disallowEmptySelection: s = !1, disallowSelectAll: c = !1, escapeKeyBehavior: u = "clearSelection", selectOnFocus: h = e.selectionBehavior === "replace", disallowTypeAhead: b = !1, shouldUseVirtualFocus: d, allowsTabNavigation: f = !1, isVirtualized: y, scrollRef: v = i, linkBehavior: K = "action" } = n, { direction: g } = yt(), m = Ge(), w = (a) => {
+    var S;
+    if (a.altKey && a.key === "Tab" && a.preventDefault(), !(!((S = i.current) === null || S === void 0) && S.contains(a.target))) return;
+    const o = (p, H) => {
+      if (p != null) {
+        if (e.isLink(p) && K === "selection" && h && !$e(a)) {
+          ft(() => {
+            e.setFocusedKey(p, H);
+          });
+          let U = le(i, p), xe = e.getItemProps(p);
+          U && m.open(U, a, xe.href, xe.routerOptions);
+          return;
+        }
+        if (e.setFocusedKey(p, H), e.isLink(p) && K === "override") return;
+        a.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(p) : h && !$e(a) && e.replaceSelection(p);
+      }
+    };
+    switch (a.key) {
+      case "ArrowDown":
+        if (t.getKeyBelow) {
+          var C, F, P;
+          let p = e.focusedKey != null ? (C = t.getKeyBelow) === null || C === void 0 ? void 0 : C.call(t, e.focusedKey) : (F = t.getFirstKey) === null || F === void 0 ? void 0 : F.call(t);
+          p == null && r && (p = (P = t.getFirstKey) === null || P === void 0 ? void 0 : P.call(t, e.focusedKey)), p != null && (a.preventDefault(), o(p));
+        }
+        break;
+      case "ArrowUp":
+        if (t.getKeyAbove) {
+          var L, N, oe;
+          let p = e.focusedKey != null ? (L = t.getKeyAbove) === null || L === void 0 ? void 0 : L.call(t, e.focusedKey) : (N = t.getLastKey) === null || N === void 0 ? void 0 : N.call(t);
+          p == null && r && (p = (oe = t.getLastKey) === null || oe === void 0 ? void 0 : oe.call(t, e.focusedKey)), p != null && (a.preventDefault(), o(p));
+        }
+        break;
+      case "ArrowLeft":
+        if (t.getKeyLeftOf) {
+          var ue, ae, ce;
+          let p = e.focusedKey != null ? (ue = t.getKeyLeftOf) === null || ue === void 0 ? void 0 : ue.call(t, e.focusedKey) : null;
+          p == null && r && (p = g === "rtl" ? (ae = t.getFirstKey) === null || ae === void 0 ? void 0 : ae.call(t, e.focusedKey) : (ce = t.getLastKey) === null || ce === void 0 ? void 0 : ce.call(t, e.focusedKey)), p != null && (a.preventDefault(), o(p, g === "rtl" ? "first" : "last"));
+        }
+        break;
+      case "ArrowRight":
+        if (t.getKeyRightOf) {
+          var de, fe, he;
+          let p = e.focusedKey != null ? (de = t.getKeyRightOf) === null || de === void 0 ? void 0 : de.call(t, e.focusedKey) : null;
+          p == null && r && (p = g === "rtl" ? (fe = t.getLastKey) === null || fe === void 0 ? void 0 : fe.call(t, e.focusedKey) : (he = t.getFirstKey) === null || he === void 0 ? void 0 : he.call(t, e.focusedKey)), p != null && (a.preventDefault(), o(p, g === "rtl" ? "last" : "first"));
+        }
+        break;
+      case "Home":
+        if (t.getFirstKey) {
+          if (e.focusedKey === null && a.shiftKey) return;
+          a.preventDefault();
+          let p = t.getFirstKey(e.focusedKey, q(a));
+          e.setFocusedKey(p), p != null && (q(a) && a.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(p) : h && e.replaceSelection(p));
+        }
+        break;
+      case "End":
+        if (t.getLastKey) {
+          if (e.focusedKey === null && a.shiftKey) return;
+          a.preventDefault();
+          let p = t.getLastKey(e.focusedKey, q(a));
+          e.setFocusedKey(p), p != null && (q(a) && a.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(p) : h && e.replaceSelection(p));
+        }
+        break;
+      case "PageDown":
+        if (t.getKeyPageBelow && e.focusedKey != null) {
+          let p = t.getKeyPageBelow(e.focusedKey);
+          p != null && (a.preventDefault(), o(p));
+        }
+        break;
+      case "PageUp":
+        if (t.getKeyPageAbove && e.focusedKey != null) {
+          let p = t.getKeyPageAbove(e.focusedKey);
+          p != null && (a.preventDefault(), o(p));
+        }
+        break;
+      case "a":
+        q(a) && e.selectionMode === "multiple" && c !== !0 && (a.preventDefault(), e.selectAll());
+        break;
+      case "Escape":
+        u === "clearSelection" && !s && e.selectedKeys.size !== 0 && (a.stopPropagation(), a.preventDefault(), e.clearSelection());
+        break;
+      case "Tab":
+        if (!f) {
+          if (a.shiftKey) i.current.focus();
+          else {
+            let p = dt(i.current, {
+              tabbable: !0
+            }), H, U;
+            do
+              U = p.lastChild(), U && (H = U);
+            while (U);
+            H && !H.contains(document.activeElement) && be(H);
+          }
+          break;
+        }
+    }
+  }, x = E({
+    top: 0,
+    left: 0
+  });
+  ee(v, "scroll", y ? void 0 : () => {
+    var a, S, o, C;
+    x.current = {
+      top: (o = (a = v.current) === null || a === void 0 ? void 0 : a.scrollTop) !== null && o !== void 0 ? o : 0,
+      left: (C = (S = v.current) === null || S === void 0 ? void 0 : S.scrollLeft) !== null && C !== void 0 ? C : 0
+    };
+  });
+  let k = (a) => {
+    if (e.isFocused) {
+      a.currentTarget.contains(a.target) || e.setFocused(!1);
+      return;
+    }
+    if (a.currentTarget.contains(a.target)) {
+      if (e.setFocused(!0), e.focusedKey == null) {
+        var S, o;
+        let P = (N) => {
+          N != null && (e.setFocusedKey(N), h && !e.isSelected(N) && e.replaceSelection(N));
+        }, L = a.relatedTarget;
+        var C, F;
+        L && a.currentTarget.compareDocumentPosition(L) & Node.DOCUMENT_POSITION_FOLLOWING ? P((C = e.lastSelectedKey) !== null && C !== void 0 ? C : (S = t.getLastKey) === null || S === void 0 ? void 0 : S.call(t)) : P((F = e.firstSelectedKey) !== null && F !== void 0 ? F : (o = t.getFirstKey) === null || o === void 0 ? void 0 : o.call(t));
+      } else !y && v.current && (v.current.scrollTop = x.current.top, v.current.scrollLeft = x.current.left);
+      if (e.focusedKey != null && v.current) {
+        let P = le(i, e.focusedKey);
+        P instanceof HTMLElement && (!P.contains(document.activeElement) && !d && be(P), Ee() === "keyboard" && Ce(P, {
+          containingElement: i.current
+        }));
+      }
+    }
+  }, M = (a) => {
+    a.currentTarget.contains(a.relatedTarget) || e.setFocused(!1);
+  }, A = E(!1);
+  ee(i, $t, d ? (a) => {
+    let { detail: S } = a;
+    a.stopPropagation(), e.setFocused(!0), S?.focusStrategy === "first" && (A.current = !0);
+  } : void 0);
+  let T = we(() => {
+    var a, S;
+    let o = (S = (a = t.getFirstKey) === null || a === void 0 ? void 0 : a.call(t)) !== null && S !== void 0 ? S : null;
+    if (o == null) {
+      let C = _e();
+      Ye(i.current), Xe(C, null), e.collection.size > 0 && (A.current = !1);
+    } else
+      e.setFocusedKey(o), A.current = !1;
+  });
+  Ie(() => {
+    A.current && T();
+  }, [
+    e.collection,
+    T
+  ]);
+  let I = we(() => {
+    e.collection.size > 0 && (A.current = !1);
+  });
+  Ie(() => {
+    I();
+  }, [
+    e.focusedKey,
+    I
+  ]), ee(i, St, d ? (a) => {
+    var S;
+    a.stopPropagation(), e.setFocused(!1), !((S = a.detail) === null || S === void 0) && S.clearFocusKey && e.setFocusedKey(null);
+  } : void 0);
+  const W = E(l), O = E(!1);
+  Y(() => {
+    if (W.current) {
+      var a, S;
+      let F = null;
+      var o;
+      l === "first" && (F = (o = (a = t.getFirstKey) === null || a === void 0 ? void 0 : a.call(t)) !== null && o !== void 0 ? o : null);
+      var C;
+      l === "last" && (F = (C = (S = t.getLastKey) === null || S === void 0 ? void 0 : S.call(t)) !== null && C !== void 0 ? C : null);
+      let P = e.selectedKeys;
+      if (P.size) {
+        for (let L of P) if (e.canSelectItem(L)) {
+          F = L;
+          break;
+        }
+      }
+      e.setFocused(!0), e.setFocusedKey(F), F == null && !d && i.current && Se(i.current), e.collection.size > 0 && (W.current = !1, O.current = !0);
+    }
+  });
+  let V = E(e.focusedKey), D = E(null);
+  Y(() => {
+    if (e.isFocused && e.focusedKey != null && (e.focusedKey !== V.current || O.current) && v.current && i.current) {
+      let a = Ee(), S = le(i, e.focusedKey);
+      if (!(S instanceof HTMLElement))
+        return;
+      (a === "keyboard" || O.current) && (D.current && cancelAnimationFrame(D.current), D.current = requestAnimationFrame(() => {
+        v.current && (ct(v.current, S), a !== "virtual" && Ce(S, {
+          containingElement: i.current
+        }));
+      }));
+    }
+    !d && e.isFocused && e.focusedKey == null && V.current != null && i.current && Se(i.current), V.current = e.focusedKey, O.current = !1;
+  }), Y(() => () => {
+    D.current && cancelAnimationFrame(D.current);
+  }, []), ee(i, "react-aria-focus-scope-restore", (a) => {
+    a.preventDefault(), e.setFocused(!0);
+  });
+  let j = {
+    onKeyDown: w,
+    onFocus: k,
+    onBlur: M,
+    onMouseDown(a) {
+      v.current === a.target && a.preventDefault();
+    }
+  }, { typeSelectProps: re } = It({
+    keyboardDelegate: t,
+    selectionManager: e
+  });
+  b || (j = J(re, j));
+  let Q;
+  d || (Q = e.focusedKey == null ? 0 : -1);
+  let se = Dt(e.collection);
+  return {
+    collectionProps: J(j, {
+      tabIndex: Q,
+      "data-collection": se
+    })
+  };
+}
+function $i(n) {
+  let { id: e, selectionManager: t, key: i, ref: l, shouldSelectOnPressUp: r, shouldUseVirtualFocus: s, focus: c, isDisabled: u, onAction: h, allowsDifferentPressOrigin: b, linkBehavior: d = "action" } = n, f = Ge();
+  e = qe(e);
+  let y = (o) => {
+    if (o.pointerType === "keyboard" && $e(o)) t.toggleSelection(i);
+    else {
+      if (t.selectionMode === "none") return;
+      if (t.isLink(i)) {
+        if (d === "selection" && l.current) {
+          let C = t.getItemProps(i);
+          f.open(l.current, o, C.href, C.routerOptions), t.setSelectedKeys(t.selectedKeys);
+          return;
+        } else if (d === "override" || d === "none") return;
+      }
+      t.selectionMode === "single" ? t.isSelected(i) && !t.disallowEmptySelection ? t.toggleSelection(i) : t.replaceSelection(i) : o && o.shiftKey ? t.extendSelection(i) : t.selectionBehavior === "toggle" || o && (q(o) || o.pointerType === "touch" || o.pointerType === "virtual") ? t.toggleSelection(i) : t.replaceSelection(i);
+    }
+  };
+  Y(() => {
+    i === t.focusedKey && t.isFocused && (s ? Ye(l.current) : c ? c() : document.activeElement !== l.current && l.current && Se(l.current));
+  }, [
+    l,
+    i,
+    t.focusedKey,
+    t.childFocusStrategy,
+    t.isFocused,
+    s
+  ]), u = u || t.isDisabled(i);
+  let v = {};
+  !s && !u ? v = {
+    tabIndex: i === t.focusedKey ? 0 : -1,
+    onFocus(o) {
+      o.target === l.current && t.setFocusedKey(i);
+    }
+  } : u && (v.onMouseDown = (o) => {
+    o.preventDefault();
+  });
+  let K = t.isLink(i) && d === "override", g = t.isLink(i) && d !== "selection" && d !== "none", m = !u && t.canSelectItem(i) && !K, w = (h || g) && !u, x = w && (t.selectionBehavior === "replace" ? !m : !m || t.isEmpty), k = w && m && t.selectionBehavior === "replace", M = x || k, A = E(null), T = M && m, I = E(!1), W = E(!1), O = t.getItemProps(i), V = (o) => {
+    h && h(), g && l.current && f.open(l.current, o, O.href, O.routerOptions);
+  }, D = {
+    ref: l
+  };
+  if (r ? (D.onPressStart = (o) => {
+    A.current = o.pointerType, I.current = T, o.pointerType === "keyboard" && (!M || Fe()) && y(o);
+  }, b ? (D.onPressUp = x ? void 0 : (o) => {
+    o.pointerType === "mouse" && m && y(o);
+  }, D.onPress = x ? V : (o) => {
+    o.pointerType !== "keyboard" && o.pointerType !== "mouse" && m && y(o);
+  }) : D.onPress = (o) => {
+    if (x || k && o.pointerType !== "mouse") {
+      if (o.pointerType === "keyboard" && !Pe()) return;
+      V(o);
+    } else o.pointerType !== "keyboard" && m && y(o);
+  }) : (D.onPressStart = (o) => {
+    A.current = o.pointerType, I.current = T, W.current = x, m && (o.pointerType === "mouse" && !x || o.pointerType === "keyboard" && (!w || Fe())) && y(o);
+  }, D.onPress = (o) => {
+    (o.pointerType === "touch" || o.pointerType === "pen" || o.pointerType === "virtual" || o.pointerType === "keyboard" && M && Pe() || o.pointerType === "mouse" && W.current) && (M ? V(o) : m && y(o));
+  }), v["data-collection"] = Et(t.collection), v["data-key"] = i, D.preventFocusOnPress = s, s && (D = J(D, {
+    onPressStart(o) {
+      o.pointerType !== "touch" && (t.setFocused(!0), t.setFocusedKey(i));
+    },
+    onPress(o) {
+      o.pointerType === "touch" && (t.setFocused(!0), t.setFocusedKey(i));
+    }
+  })), O)
+    for (let o of [
+      "onPressStart",
+      "onPressEnd",
+      "onPressChange",
+      "onPress",
+      "onPressUp",
+      "onClick"
+    ]) O[o] && (D[o] = ot(D[o], O[o]));
+  let { pressProps: j, isPressed: re } = We(D), Q = k ? (o) => {
+    A.current === "mouse" && (o.stopPropagation(), o.preventDefault(), V(o));
+  } : void 0, { longPressProps: se } = xt({
+    isDisabled: !T,
+    onLongPress(o) {
+      o.pointerType === "touch" && (y(o), t.setSelectionBehavior("toggle"));
+    }
+  }), a = (o) => {
+    A.current === "touch" && I.current && o.preventDefault();
+  }, S = d !== "none" && t.isLink(i) ? (o) => {
+    ut.isOpening || o.preventDefault();
+  } : void 0;
+  return {
+    itemProps: J(
+      v,
+      m || x || s && !u ? j : {},
+      T ? se : {},
+      {
+        onDoubleClick: Q,
+        onDragStartCapture: a,
+        onClick: S,
+        id: e
+      },
+      // Prevent DOM focus from moving on mouse down when using virtual focus
+      s ? {
+        onMouseDown: (o) => o.preventDefault()
+      } : void 0
+    ),
+    isPressed: re,
+    isSelected: t.isSelected(i),
+    isFocused: t.isFocused && t.focusedKey === i,
+    isDisabled: u,
+    allowsSelection: m,
+    hasAction: M
+  };
+}
+function Pe() {
+  let n = window.event;
+  return n?.key === "Enter";
+}
+function Fe() {
+  let n = window.event;
+  return n?.key === " " || n?.code === "Space";
+}
+class Me {
+  getItemRect(e) {
+    let t = this.ref.current;
+    if (!t) return null;
+    let i = e != null ? le(this.ref, e) : null;
+    if (!i) return null;
+    let l = t.getBoundingClientRect(), r = i.getBoundingClientRect();
+    return {
+      x: r.left - l.left + t.scrollLeft,
+      y: r.top - l.top + t.scrollTop,
+      width: r.width,
+      height: r.height
+    };
+  }
+  getContentSize() {
+    let e = this.ref.current;
+    var t, i;
+    return {
+      width: (t = e?.scrollWidth) !== null && t !== void 0 ? t : 0,
+      height: (i = e?.scrollHeight) !== null && i !== void 0 ? i : 0
+    };
+  }
+  getVisibleRect() {
+    let e = this.ref.current;
+    var t, i, l, r;
+    return {
+      x: (t = e?.scrollLeft) !== null && t !== void 0 ? t : 0,
+      y: (i = e?.scrollTop) !== null && i !== void 0 ? i : 0,
+      width: (l = e?.offsetWidth) !== null && l !== void 0 ? l : 0,
+      height: (r = e?.offsetHeight) !== null && r !== void 0 ? r : 0
+    };
+  }
+  constructor(e) {
+    this.ref = e;
+  }
+}
+class Ki {
+  isDisabled(e) {
+    var t;
+    return this.disabledBehavior === "all" && (((t = e.props) === null || t === void 0 ? void 0 : t.isDisabled) || this.disabledKeys.has(e.key));
+  }
+  findNextNonDisabled(e, t) {
+    let i = e;
+    for (; i != null; ) {
+      let l = this.collection.getItem(i);
+      if (l?.type === "item" && !this.isDisabled(l)) return i;
+      i = t(i);
+    }
+    return null;
+  }
+  getNextKey(e) {
+    let t = e;
+    return t = this.collection.getKeyAfter(t), this.findNextNonDisabled(t, (i) => this.collection.getKeyAfter(i));
+  }
+  getPreviousKey(e) {
+    let t = e;
+    return t = this.collection.getKeyBefore(t), this.findNextNonDisabled(t, (i) => this.collection.getKeyBefore(i));
+  }
+  findKey(e, t, i) {
+    let l = e, r = this.layoutDelegate.getItemRect(l);
+    if (!r || l == null) return null;
+    let s = r;
+    do {
+      if (l = t(l), l == null) break;
+      r = this.layoutDelegate.getItemRect(l);
+    } while (r && i(s, r) && l != null);
+    return l;
+  }
+  isSameRow(e, t) {
+    return e.y === t.y || e.x !== t.x;
+  }
+  isSameColumn(e, t) {
+    return e.x === t.x || e.y !== t.y;
+  }
+  getKeyBelow(e) {
+    return this.layout === "grid" && this.orientation === "vertical" ? this.findKey(e, (t) => this.getNextKey(t), this.isSameRow) : this.getNextKey(e);
+  }
+  getKeyAbove(e) {
+    return this.layout === "grid" && this.orientation === "vertical" ? this.findKey(e, (t) => this.getPreviousKey(t), this.isSameRow) : this.getPreviousKey(e);
+  }
+  getNextColumn(e, t) {
+    return t ? this.getPreviousKey(e) : this.getNextKey(e);
+  }
+  getKeyRightOf(e) {
+    let t = this.direction === "ltr" ? "getKeyRightOf" : "getKeyLeftOf";
+    return this.layoutDelegate[t] ? (e = this.layoutDelegate[t](e), this.findNextNonDisabled(e, (i) => this.layoutDelegate[t](i))) : this.layout === "grid" ? this.orientation === "vertical" ? this.getNextColumn(e, this.direction === "rtl") : this.findKey(e, (i) => this.getNextColumn(i, this.direction === "rtl"), this.isSameColumn) : this.orientation === "horizontal" ? this.getNextColumn(e, this.direction === "rtl") : null;
+  }
+  getKeyLeftOf(e) {
+    let t = this.direction === "ltr" ? "getKeyLeftOf" : "getKeyRightOf";
+    return this.layoutDelegate[t] ? (e = this.layoutDelegate[t](e), this.findNextNonDisabled(e, (i) => this.layoutDelegate[t](i))) : this.layout === "grid" ? this.orientation === "vertical" ? this.getNextColumn(e, this.direction === "ltr") : this.findKey(e, (i) => this.getNextColumn(i, this.direction === "ltr"), this.isSameColumn) : this.orientation === "horizontal" ? this.getNextColumn(e, this.direction === "ltr") : null;
+  }
+  getFirstKey() {
+    let e = this.collection.getFirstKey();
+    return this.findNextNonDisabled(e, (t) => this.collection.getKeyAfter(t));
+  }
+  getLastKey() {
+    let e = this.collection.getLastKey();
+    return this.findNextNonDisabled(e, (t) => this.collection.getKeyBefore(t));
+  }
+  getKeyPageAbove(e) {
+    let t = this.ref.current, i = this.layoutDelegate.getItemRect(e);
+    if (!i) return null;
+    if (t && !De(t)) return this.getFirstKey();
+    let l = e;
+    if (this.orientation === "horizontal") {
+      let r = Math.max(0, i.x + i.width - this.layoutDelegate.getVisibleRect().width);
+      for (; i && i.x > r && l != null; )
+        l = this.getKeyAbove(l), i = l == null ? null : this.layoutDelegate.getItemRect(l);
+    } else {
+      let r = Math.max(0, i.y + i.height - this.layoutDelegate.getVisibleRect().height);
+      for (; i && i.y > r && l != null; )
+        l = this.getKeyAbove(l), i = l == null ? null : this.layoutDelegate.getItemRect(l);
+    }
+    return l ?? this.getFirstKey();
+  }
+  getKeyPageBelow(e) {
+    let t = this.ref.current, i = this.layoutDelegate.getItemRect(e);
+    if (!i) return null;
+    if (t && !De(t)) return this.getLastKey();
+    let l = e;
+    if (this.orientation === "horizontal") {
+      let r = Math.min(this.layoutDelegate.getContentSize().width, i.y - i.width + this.layoutDelegate.getVisibleRect().width);
+      for (; i && i.x < r && l != null; )
+        l = this.getKeyBelow(l), i = l == null ? null : this.layoutDelegate.getItemRect(l);
+    } else {
+      let r = Math.min(this.layoutDelegate.getContentSize().height, i.y - i.height + this.layoutDelegate.getVisibleRect().height);
+      for (; i && i.y < r && l != null; )
+        l = this.getKeyBelow(l), i = l == null ? null : this.layoutDelegate.getItemRect(l);
+    }
+    return l ?? this.getLastKey();
+  }
+  getKeyForSearch(e, t) {
+    if (!this.collator) return null;
+    let i = this.collection, l = t || this.getFirstKey();
+    for (; l != null; ) {
+      let r = i.getItem(l);
+      if (!r) return null;
+      let s = r.textValue.slice(0, e.length);
+      if (r.textValue && this.collator.compare(s, e) === 0) return l;
+      l = this.getNextKey(l);
+    }
+    return null;
+  }
+  constructor(...e) {
+    if (e.length === 1) {
+      let t = e[0];
+      this.collection = t.collection, this.ref = t.ref, this.collator = t.collator, this.disabledKeys = t.disabledKeys || /* @__PURE__ */ new Set(), this.disabledBehavior = t.disabledBehavior || "all", this.orientation = t.orientation || "vertical", this.direction = t.direction, this.layout = t.layout || "stack", this.layoutDelegate = t.layoutDelegate || new Me(t.ref);
+    } else
+      this.collection = e[0], this.disabledKeys = e[1], this.ref = e[2], this.collator = e[3], this.layout = "stack", this.orientation = "vertical", this.disabledBehavior = "all", this.layoutDelegate = new Me(this.ref);
+    this.layout === "stack" && this.orientation === "vertical" && (this.getKeyLeftOf = void 0, this.getKeyRightOf = void 0);
+  }
+}
+class Ft {
+  build(e, t) {
+    return this.context = t, Ae(() => this.iterateCollection(e));
+  }
+  *iterateCollection(e) {
+    let { children: t, items: i } = e;
+    if ($.isValidElement(t) && t.type === $.Fragment) yield* this.iterateCollection({
+      children: t.props.children,
+      items: i
+    });
+    else if (typeof t == "function") {
+      if (!i) throw new Error("props.children was a function but props.items is missing");
+      let l = 0;
+      for (let r of i)
+        yield* this.getFullNode({
+          value: r,
+          index: l
+        }, {
+          renderer: t
+        }), l++;
+    } else {
+      let l = [];
+      $.Children.forEach(t, (s) => {
+        s && l.push(s);
+      });
+      let r = 0;
+      for (let s of l) {
+        let c = this.getFullNode({
+          element: s,
+          index: r
+        }, {});
+        for (let u of c)
+          r++, yield u;
+      }
+    }
+  }
+  getKey(e, t, i, l) {
+    if (e.key != null) return e.key;
+    if (t.type === "cell" && t.key != null) return `${l}${t.key}`;
+    let r = t.value;
+    if (r != null) {
+      var s;
+      let c = (s = r.key) !== null && s !== void 0 ? s : r.id;
+      if (c == null) throw new Error("No key found for item");
+      return c;
+    }
+    return l ? `${l}.${t.index}` : `$.${t.index}`;
+  }
+  getChildState(e, t) {
+    return {
+      renderer: t.renderer || e.renderer
+    };
+  }
+  *getFullNode(e, t, i, l) {
+    if ($.isValidElement(e.element) && e.element.type === $.Fragment) {
+      let g = [];
+      $.Children.forEach(e.element.props.children, (w) => {
+        g.push(w);
+      });
+      var r;
+      let m = (r = e.index) !== null && r !== void 0 ? r : 0;
+      for (const w of g) yield* this.getFullNode({
+        element: w,
+        index: m++
+      }, t, i, l);
+      return;
+    }
+    let s = e.element;
+    if (!s && e.value && t && t.renderer) {
+      let g = this.cache.get(e.value);
+      if (g && (!g.shouldInvalidate || !g.shouldInvalidate(this.context))) {
+        g.index = e.index, g.parentKey = l ? l.key : null, yield g;
+        return;
+      }
+      s = t.renderer(e.value);
+    }
+    if ($.isValidElement(s)) {
+      let g = s.type;
+      if (typeof g != "function" && typeof g.getCollectionNode != "function") {
+        let k = s.type;
+        throw new Error(`Unknown element <${k}> in collection.`);
+      }
+      let m = g.getCollectionNode(s.props, this.context);
+      var c;
+      let w = (c = e.index) !== null && c !== void 0 ? c : 0, x = m.next();
+      for (; !x.done && x.value; ) {
+        let k = x.value;
+        e.index = w;
+        var u;
+        let M = (u = k.key) !== null && u !== void 0 ? u : null;
+        M == null && (M = k.element ? null : this.getKey(s, e, t, i));
+        let T = [
+          ...this.getFullNode({
+            ...k,
+            key: M,
+            index: w,
+            wrapper: Mt(e.wrapper, k.wrapper)
+          }, this.getChildState(t, k), i ? `${i}${s.key}` : s.key, l)
+        ];
+        for (let I of T) {
+          var h, b;
+          I.value = (b = (h = k.value) !== null && h !== void 0 ? h : e.value) !== null && b !== void 0 ? b : null, I.value && this.cache.set(I.value, I);
+          var d;
+          if (e.type && I.type !== e.type) throw new Error(`Unsupported type <${ye(I.type)}> in <${ye((d = l?.type) !== null && d !== void 0 ? d : "unknown parent type")}>. Only <${ye(e.type)}> is supported.`);
+          w++, yield I;
+        }
+        x = m.next(T);
+      }
+      return;
+    }
+    if (e.key == null || e.type == null) return;
+    let f = this;
+    var y, v;
+    let K = {
+      type: e.type,
+      props: e.props,
+      key: e.key,
+      parentKey: l ? l.key : null,
+      value: (y = e.value) !== null && y !== void 0 ? y : null,
+      level: l ? l.level + 1 : 0,
+      index: e.index,
+      rendered: e.rendered,
+      textValue: (v = e.textValue) !== null && v !== void 0 ? v : "",
+      "aria-label": e["aria-label"],
+      wrapper: e.wrapper,
+      shouldInvalidate: e.shouldInvalidate,
+      hasChildNodes: e.hasChildNodes || !1,
+      childNodes: Ae(function* () {
+        if (!e.hasChildNodes || !e.childNodes) return;
+        let g = 0;
+        for (let m of e.childNodes()) {
+          m.key != null && (m.key = `${K.key}${m.key}`);
+          let w = f.getFullNode({
+            ...m,
+            index: g
+          }, f.getChildState(t, m), K.key, K);
+          for (let x of w)
+            g++, yield x;
+        }
+      })
+    };
+    yield K;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+function Ae(n) {
+  let e = [], t = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let i of e) yield i;
+      t || (t = n());
+      for (let i of t)
+        e.push(i), yield i;
+    }
+  };
+}
+function Mt(n, e) {
+  if (n && e) return (t) => n(e(t));
+  if (n) return n;
+  if (e) return e;
+}
+function ye(n) {
+  return n[0].toUpperCase() + n.slice(1);
+}
+function xi(n, e, t) {
+  let i = B(() => new Ft(), []), { children: l, items: r, collection: s } = n;
+  return B(() => {
+    if (s) return s;
+    let u = i.build({
+      children: l,
+      items: r
+    }, t);
+    return e(u);
+  }, [
+    i,
+    l,
+    r,
+    s,
+    t,
+    e
+  ]);
+}
+function At(n, e) {
+  return typeof e.getChildren == "function" ? e.getChildren(n.key) : n.childNodes;
+}
+function Rt(n) {
+  return Tt(n, 0);
+}
+function Tt(n, e) {
+  if (e < 0) return;
+  let t = 0;
+  for (let i of n) {
+    if (t === e) return i;
+    t++;
+  }
+}
+function wi(n) {
+  let e;
+  for (let t of n) e = t;
+  return e;
+}
+function pe(n, e, t) {
+  if (e.parentKey === t.parentKey) return e.index - t.index;
+  let i = [
+    ...Re(n, e),
+    e
+  ], l = [
+    ...Re(n, t),
+    t
+  ], r = i.slice(0, l.length).findIndex((s, c) => s !== l[c]);
+  return r !== -1 ? (e = i[r], t = l[r], e.index - t.index) : i.findIndex((s) => s === t) >= 0 ? 1 : (l.findIndex((s) => s === e) >= 0, -1);
+}
+function Re(n, e) {
+  let t = [], i = e;
+  for (; i?.parentKey != null; )
+    i = n.getItem(i.parentKey), i && t.unshift(i);
+  return t;
+}
+var te = { exports: {} }, ve = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Te;
+function Ot() {
+  if (Te) return ve;
+  Te = 1;
+  var n = $;
+  function e(d, f) {
+    return d === f && (d !== 0 || 1 / d === 1 / f) || d !== d && f !== f;
+  }
+  var t = typeof Object.is == "function" ? Object.is : e, i = n.useState, l = n.useEffect, r = n.useLayoutEffect, s = n.useDebugValue;
+  function c(d, f) {
+    var y = f(), v = i({ inst: { value: y, getSnapshot: f } }), K = v[0].inst, g = v[1];
+    return r(
+      function() {
+        K.value = y, K.getSnapshot = f, u(K) && g({ inst: K });
+      },
+      [d, y, f]
+    ), l(
+      function() {
+        return u(K) && g({ inst: K }), d(function() {
+          u(K) && g({ inst: K });
+        });
+      },
+      [d]
+    ), s(y), y;
+  }
+  function u(d) {
+    var f = d.getSnapshot;
+    d = d.value;
+    try {
+      var y = f();
+      return !t(d, y);
+    } catch {
+      return !0;
+    }
+  }
+  function h(d, f) {
+    return f();
+  }
+  var b = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? h : c;
+  return ve.useSyncExternalStore = n.useSyncExternalStore !== void 0 ? n.useSyncExternalStore : b, ve;
+}
+var ge = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Oe;
+function Lt() {
+  return Oe || (Oe = 1, process.env.NODE_ENV !== "production" && (function() {
+    function n(y, v) {
+      return y === v && (y !== 0 || 1 / y === 1 / v) || y !== y && v !== v;
+    }
+    function e(y, v) {
+      b || l.startTransition === void 0 || (b = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var K = v();
+      if (!d) {
+        var g = v();
+        r(K, g) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), d = !0);
+      }
+      g = s({
+        inst: { value: K, getSnapshot: v }
+      });
+      var m = g[0].inst, w = g[1];
+      return u(
+        function() {
+          m.value = K, m.getSnapshot = v, t(m) && w({ inst: m });
+        },
+        [y, K, v]
+      ), c(
+        function() {
+          return t(m) && w({ inst: m }), y(function() {
+            t(m) && w({ inst: m });
+          });
+        },
+        [y]
+      ), h(K), K;
+    }
+    function t(y) {
+      var v = y.getSnapshot;
+      y = y.value;
+      try {
+        var K = v();
+        return !r(y, K);
+      } catch {
+        return !0;
+      }
+    }
+    function i(y, v) {
+      return v();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var l = $, r = typeof Object.is == "function" ? Object.is : n, s = l.useState, c = l.useEffect, u = l.useLayoutEffect, h = l.useDebugValue, b = !1, d = !1, f = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? i : e;
+    ge.useSyncExternalStore = l.useSyncExternalStore !== void 0 ? l.useSyncExternalStore : f, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), ge;
+}
+var Le;
+function Bt() {
+  return Le || (Le = 1, process.env.NODE_ENV === "production" ? te.exports = Ot() : te.exports = Lt()), te.exports;
+}
+var Vt = /* @__PURE__ */ Bt();
+const Ci = /* @__PURE__ */ z(null), Di = /* @__PURE__ */ z(null);
+class ne {
+  get childNodes() {
+    throw new Error("childNodes is not supported");
+  }
+  clone() {
+    let e = new this.constructor(this.key);
+    return e.value = this.value, e.level = this.level, e.hasChildNodes = this.hasChildNodes, e.rendered = this.rendered, e.textValue = this.textValue, e["aria-label"] = this["aria-label"], e.index = this.index, e.parentKey = this.parentKey, e.prevKey = this.prevKey, e.nextKey = this.nextKey, e.firstChildKey = this.firstChildKey, e.lastChildKey = this.lastChildKey, e.props = this.props, e.render = this.render, e.colSpan = this.colSpan, e.colIndex = this.colIndex, e;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  filter(e, t, i) {
+    let l = this.clone();
+    return t.addDescendants(l, e), l;
+  }
+  constructor(e) {
+    this.value = null, this.level = 0, this.hasChildNodes = !1, this.rendered = null, this.textValue = "", this["aria-label"] = void 0, this.index = 0, this.parentKey = null, this.prevKey = null, this.nextKey = null, this.firstChildKey = null, this.lastChildKey = null, this.props = {}, this.colSpan = null, this.colIndex = null, this.type = this.constructor.type, this.key = e;
+  }
+}
+class Ze extends ne {
+  filter(e, t, i) {
+    let [l, r] = Qe(e, t, this.firstChildKey, i), s = this.clone();
+    return s.firstChildKey = l, s.lastChildKey = r, s;
+  }
+}
+class Nt extends ne {
+}
+Nt.type = "header";
+class zt extends ne {
+}
+zt.type = "loader";
+class Ht extends Ze {
+  filter(e, t, i) {
+    if (i(this.textValue, this)) {
+      let l = this.clone();
+      return t.addDescendants(l, e), l;
+    }
+    return null;
+  }
+}
+Ht.type = "item";
+class Ut extends Ze {
+  filter(e, t, i) {
+    let l = super.filter(e, t, i);
+    if (l && l.lastChildKey !== null) {
+      let r = e.getItem(l.lastChildKey);
+      if (r && r.type !== "header") return l;
+    }
+    return null;
+  }
+}
+Ut.type = "section";
+class _t {
+  get size() {
+    return this.itemCount;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  *[Symbol.iterator]() {
+    let e = this.firstKey != null ? this.keyMap.get(this.firstKey) : void 0;
+    for (; e; )
+      yield e, e = e.nextKey != null ? this.keyMap.get(e.nextKey) : void 0;
+  }
+  getChildren(e) {
+    let t = this.keyMap;
+    return {
+      *[Symbol.iterator]() {
+        let i = t.get(e), l = i?.firstChildKey != null ? t.get(i.firstChildKey) : null;
+        for (; l; )
+          yield l, l = l.nextKey != null ? t.get(l.nextKey) : void 0;
+      }
+    };
+  }
+  getKeyBefore(e) {
+    let t = this.keyMap.get(e);
+    if (!t) return null;
+    if (t.prevKey != null) {
+      for (t = this.keyMap.get(t.prevKey); t && t.type !== "item" && t.lastChildKey != null; ) t = this.keyMap.get(t.lastChildKey);
+      var i;
+      return (i = t?.key) !== null && i !== void 0 ? i : null;
+    }
+    return t.parentKey;
+  }
+  getKeyAfter(e) {
+    let t = this.keyMap.get(e);
+    if (!t) return null;
+    if (t.type !== "item" && t.firstChildKey != null) return t.firstChildKey;
+    for (; t; ) {
+      if (t.nextKey != null) return t.nextKey;
+      if (t.parentKey != null) t = this.keyMap.get(t.parentKey);
+      else return null;
+    }
+    return null;
+  }
+  getFirstKey() {
+    return this.firstKey;
+  }
+  getLastKey() {
+    let e = this.lastKey != null ? this.keyMap.get(this.lastKey) : null;
+    for (; e?.lastChildKey != null; ) e = this.keyMap.get(e.lastChildKey);
+    var t;
+    return (t = e?.key) !== null && t !== void 0 ? t : null;
+  }
+  getItem(e) {
+    var t;
+    return (t = this.keyMap.get(e)) !== null && t !== void 0 ? t : null;
+  }
+  at() {
+    throw new Error("Not implemented");
+  }
+  clone() {
+    let e = this.constructor, t = new e();
+    return t.keyMap = new Map(this.keyMap), t.firstKey = this.firstKey, t.lastKey = this.lastKey, t.itemCount = this.itemCount, t;
+  }
+  addNode(e) {
+    if (this.frozen) throw new Error("Cannot add a node to a frozen collection");
+    e.type === "item" && this.keyMap.get(e.key) == null && this.itemCount++, this.keyMap.set(e.key, e);
+  }
+  // Deeply add a node and its children to the collection from another collection, primarily used when filtering a collection
+  addDescendants(e, t) {
+    this.addNode(e);
+    let i = t.getChildren(e.key);
+    for (let l of i) this.addDescendants(l, t);
+  }
+  removeNode(e) {
+    if (this.frozen) throw new Error("Cannot remove a node to a frozen collection");
+    let t = this.keyMap.get(e);
+    t != null && t.type === "item" && this.itemCount--, this.keyMap.delete(e);
+  }
+  commit(e, t, i = !1) {
+    if (this.frozen) throw new Error("Cannot commit a frozen collection");
+    this.firstKey = e, this.lastKey = t, this.frozen = !i;
+  }
+  filter(e) {
+    let t = new this.constructor(), [i, l] = Qe(this, t, this.firstKey, e);
+    return t?.commit(i, l), t;
+  }
+  constructor() {
+    this.keyMap = /* @__PURE__ */ new Map(), this.firstKey = null, this.lastKey = null, this.frozen = !1, this.itemCount = 0;
+  }
+}
+function Qe(n, e, t, i) {
+  if (t == null) return [
+    null,
+    null
+  ];
+  let l = null, r = null, s = n.getItem(t);
+  for (; s != null; ) {
+    let h = s.filter(n, e, i);
+    h != null && (h.nextKey = null, r && (h.prevKey = r.key, r.nextKey = h.key), l == null && (l = h), e.addNode(h), r = h), s = s.nextKey ? n.getItem(s.nextKey) : null;
+  }
+  if (r && r.type === "separator") {
+    let h = r.prevKey;
+    e.removeNode(r.key), h ? (r = e.getItem(h), r.nextKey = null) : r = null;
+  }
+  var c, u;
+  return [
+    (c = l?.key) !== null && c !== void 0 ? c : null,
+    (u = r?.key) !== null && u !== void 0 ? u : null
+  ];
+}
+class et {
+  *[Symbol.iterator]() {
+    let e = this.firstChild;
+    for (; e; )
+      yield e, e = e.nextSibling;
+  }
+  get firstChild() {
+    return this._firstChild;
+  }
+  set firstChild(e) {
+    this._firstChild = e, this.ownerDocument.markDirty(this);
+  }
+  get lastChild() {
+    return this._lastChild;
+  }
+  set lastChild(e) {
+    this._lastChild = e, this.ownerDocument.markDirty(this);
+  }
+  get previousSibling() {
+    return this._previousSibling;
+  }
+  set previousSibling(e) {
+    this._previousSibling = e, this.ownerDocument.markDirty(this);
+  }
+  get nextSibling() {
+    return this._nextSibling;
+  }
+  set nextSibling(e) {
+    this._nextSibling = e, this.ownerDocument.markDirty(this);
+  }
+  get parentNode() {
+    return this._parentNode;
+  }
+  set parentNode(e) {
+    this._parentNode = e, this.ownerDocument.markDirty(this);
+  }
+  get isConnected() {
+    var e;
+    return ((e = this.parentNode) === null || e === void 0 ? void 0 : e.isConnected) || !1;
+  }
+  invalidateChildIndices(e) {
+    (this._minInvalidChildIndex == null || !this._minInvalidChildIndex.isConnected || e.index < this._minInvalidChildIndex.index) && (this._minInvalidChildIndex = e, this.ownerDocument.markDirty(this));
+  }
+  updateChildIndices() {
+    let e = this._minInvalidChildIndex;
+    for (; e; )
+      e.index = e.previousSibling ? e.previousSibling.index + 1 : 0, e = e.nextSibling;
+    this._minInvalidChildIndex = null;
+  }
+  appendChild(e) {
+    e.parentNode && e.parentNode.removeChild(e), this.firstChild == null && (this.firstChild = e), this.lastChild ? (this.lastChild.nextSibling = e, e.index = this.lastChild.index + 1, e.previousSibling = this.lastChild) : (e.previousSibling = null, e.index = 0), e.parentNode = this, e.nextSibling = null, this.lastChild = e, this.ownerDocument.markDirty(this), this.isConnected && this.ownerDocument.queueUpdate();
+  }
+  insertBefore(e, t) {
+    if (t == null) return this.appendChild(e);
+    e.parentNode && e.parentNode.removeChild(e), e.nextSibling = t, e.previousSibling = t.previousSibling, e.index = t.index - 1, this.firstChild === t ? this.firstChild = e : t.previousSibling && (t.previousSibling.nextSibling = e), t.previousSibling = e, e.parentNode = t.parentNode, this.invalidateChildIndices(e), this.isConnected && this.ownerDocument.queueUpdate();
+  }
+  removeChild(e) {
+    e.parentNode !== this || !this.ownerDocument.isMounted || (this._minInvalidChildIndex === e && (this._minInvalidChildIndex = null), e.nextSibling && (this.invalidateChildIndices(e.nextSibling), e.nextSibling.previousSibling = e.previousSibling), e.previousSibling && (e.previousSibling.nextSibling = e.nextSibling), this.firstChild === e && (this.firstChild = e.nextSibling), this.lastChild === e && (this.lastChild = e.previousSibling), e.parentNode = null, e.nextSibling = null, e.previousSibling = null, e.index = 0, this.ownerDocument.markDirty(e), this.isConnected && this.ownerDocument.queueUpdate());
+  }
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  get previousVisibleSibling() {
+    let e = this.previousSibling;
+    for (; e && e.isHidden; ) e = e.previousSibling;
+    return e;
+  }
+  get nextVisibleSibling() {
+    let e = this.nextSibling;
+    for (; e && e.isHidden; ) e = e.nextSibling;
+    return e;
+  }
+  get firstVisibleChild() {
+    let e = this.firstChild;
+    for (; e && e.isHidden; ) e = e.nextSibling;
+    return e;
+  }
+  get lastVisibleChild() {
+    let e = this.lastChild;
+    for (; e && e.isHidden; ) e = e.previousSibling;
+    return e;
+  }
+  constructor(e) {
+    this._firstChild = null, this._lastChild = null, this._previousSibling = null, this._nextSibling = null, this._parentNode = null, this._minInvalidChildIndex = null, this.ownerDocument = e;
+  }
+}
+class G extends et {
+  get index() {
+    return this._index;
+  }
+  set index(e) {
+    this._index = e, this.ownerDocument.markDirty(this);
+  }
+  get level() {
+    var e;
+    return this.parentNode instanceof G ? this.parentNode.level + (((e = this.node) === null || e === void 0 ? void 0 : e.type) === "item" ? 1 : 0) : 0;
+  }
+  get node() {
+    if (this._node == null) throw Error("Attempted to access node before it was defined. Check if setProps wasn't called before attempting to access the node.");
+    return this._node;
+  }
+  set node(e) {
+    this._node = e;
+  }
+  /**
+  * Lazily gets a mutable instance of a Node. If the node has already
+  * been cloned during this update cycle, it just returns the existing one.
+  */
+  getMutableNode() {
+    return this.isMutated || (this.node = this.node.clone(), this.isMutated = !0), this.ownerDocument.markDirty(this), this.node;
+  }
+  updateNode() {
+    var e, t, i;
+    let l = this.nextVisibleSibling, r = this.getMutableNode();
+    r.index = this.index, r.level = this.level, r.parentKey = this.parentNode instanceof G ? this.parentNode.node.key : null;
+    var s;
+    r.prevKey = (s = (e = this.previousVisibleSibling) === null || e === void 0 ? void 0 : e.node.key) !== null && s !== void 0 ? s : null;
+    var c;
+    r.nextKey = (c = l?.node.key) !== null && c !== void 0 ? c : null, r.hasChildNodes = !!this.firstChild;
+    var u;
+    r.firstChildKey = (u = (t = this.firstVisibleChild) === null || t === void 0 ? void 0 : t.node.key) !== null && u !== void 0 ? u : null;
+    var h;
+    if (r.lastChildKey = (h = (i = this.lastVisibleChild) === null || i === void 0 ? void 0 : i.node.key) !== null && h !== void 0 ? h : null, (r.colSpan != null || r.colIndex != null) && l) {
+      var b, d;
+      let f = ((b = r.colIndex) !== null && b !== void 0 ? b : r.index) + ((d = r.colSpan) !== null && d !== void 0 ? d : 1);
+      if (f !== l.node.colIndex) {
+        let y = l.getMutableNode();
+        y.colIndex = f;
+      }
+    }
+  }
+  setProps(e, t, i, l, r) {
+    let s, { value: c, textValue: u, id: h, ...b } = e;
+    if (this._node == null ? (s = new i(h ?? `react-aria-${++this.ownerDocument.nodeId}`), this.node = s) : s = this.getMutableNode(), b.ref = t, s.props = b, s.rendered = l, s.render = r, s.value = c, s.textValue = u || (typeof b.children == "string" ? b.children : "") || e["aria-label"] || "", h != null && h !== s.key) throw new Error("Cannot change the id of an item");
+    b.colSpan != null && (s.colSpan = b.colSpan), this.isConnected && this.ownerDocument.queueUpdate();
+  }
+  get style() {
+    let e = this;
+    return {
+      get display() {
+        return e.isHidden ? "none" : "";
+      },
+      set display(t) {
+        let i = t === "none";
+        if (e.isHidden !== i) {
+          var l, r;
+          (((l = e.parentNode) === null || l === void 0 ? void 0 : l.firstVisibleChild) === e || ((r = e.parentNode) === null || r === void 0 ? void 0 : r.lastVisibleChild) === e) && e.ownerDocument.markDirty(e.parentNode);
+          let s = e.previousVisibleSibling, c = e.nextVisibleSibling;
+          s && e.ownerDocument.markDirty(s), c && e.ownerDocument.markDirty(c), e.isHidden = i, e.ownerDocument.markDirty(e);
+        }
+      }
+    };
+  }
+  hasAttribute() {
+  }
+  setAttribute() {
+  }
+  setAttributeNS() {
+  }
+  removeAttribute() {
+  }
+  constructor(e, t) {
+    super(t), this.nodeType = 8, this.isMutated = !0, this._index = 0, this.isHidden = !1, this._node = null;
+  }
+}
+class qt extends et {
+  get isConnected() {
+    return this.isMounted;
+  }
+  createElement(e) {
+    return new G(e, this);
+  }
+  getMutableCollection() {
+    return this.nextCollection || (this.nextCollection = this.collection.clone()), this.nextCollection;
+  }
+  markDirty(e) {
+    this.dirtyNodes.add(e);
+  }
+  addNode(e) {
+    if (e.isHidden) return;
+    let t = this.getMutableCollection();
+    if (!t.getItem(e.node.key)) for (let i of e) this.addNode(i);
+    t.addNode(e.node);
+  }
+  removeNode(e) {
+    for (let i of e) this.removeNode(i);
+    this.getMutableCollection().removeNode(e.node.key);
+  }
+  /** Finalizes the collection update, updating all nodes and freezing the collection. */
+  getCollection() {
+    return this.inSubscription ? this.collection.clone() : (this.queuedRender = !1, this.updateCollection(), this.collection);
+  }
+  updateCollection() {
+    for (let r of this.dirtyNodes) r instanceof G && (!r.isConnected || r.isHidden) ? this.removeNode(r) : r.updateChildIndices();
+    for (let r of this.dirtyNodes) r instanceof G && (r.isConnected && !r.isHidden && (r.updateNode(), this.addNode(r)), r.isMutated = !1);
+    if (this.dirtyNodes.clear(), this.nextCollection) {
+      var e, t, i, l;
+      this.nextCollection.commit((i = (e = this.firstVisibleChild) === null || e === void 0 ? void 0 : e.node.key) !== null && i !== void 0 ? i : null, (l = (t = this.lastVisibleChild) === null || t === void 0 ? void 0 : t.node.key) !== null && l !== void 0 ? l : null, this.isSSR), this.isSSR || (this.collection = this.nextCollection, this.nextCollection = null);
+    }
+  }
+  queueUpdate() {
+    if (!(this.dirtyNodes.size === 0 || this.queuedRender)) {
+      this.queuedRender = !0, this.inSubscription = !0;
+      for (let e of this.subscriptions) e();
+      this.inSubscription = !1;
+    }
+  }
+  subscribe(e) {
+    return this.subscriptions.add(e), () => this.subscriptions.delete(e);
+  }
+  resetAfterSSR() {
+    this.isSSR && (this.isSSR = !1, this.firstChild = null, this.lastChild = null, this.nodeId = 0);
+  }
+  constructor(e) {
+    super(null), this.nodeType = 11, this.ownerDocument = this, this.dirtyNodes = /* @__PURE__ */ new Set(), this.isSSR = !1, this.nodeId = 0, this.nodesByProps = /* @__PURE__ */ new WeakMap(), this.isMounted = !0, this.nextCollection = null, this.subscriptions = /* @__PURE__ */ new Set(), this.queuedRender = !1, this.inSubscription = !1, this.collection = e, this.nextCollection = e;
+  }
+}
+function tt(n) {
+  let { children: e, items: t, idScope: i, addIdAndValue: l, dependencies: r = [] } = n, s = B(() => /* @__PURE__ */ new WeakMap(), r);
+  return B(() => {
+    if (t && typeof e == "function") {
+      let h = [];
+      for (let b of t) {
+        let d = s.get(b);
+        if (!d) {
+          d = e(b);
+          var c, u;
+          let f = (u = (c = d.props.id) !== null && c !== void 0 ? c : b.key) !== null && u !== void 0 ? u : b.id;
+          if (f == null) throw new Error("Could not determine key for item");
+          i && (f = i + ":" + f), d = ze(d, l ? {
+            key: f,
+            id: f,
+            value: b
+          } : {
+            key: f
+          }), s.set(b, d);
+        }
+        h.push(d);
+      }
+      return h;
+    } else if (typeof e != "function") return e;
+  }, [
+    e,
+    t,
+    s,
+    i,
+    l
+  ]);
+}
+const it = /* @__PURE__ */ z(!1), Z = /* @__PURE__ */ z(null);
+function Ei(n) {
+  if (_(Z))
+    return n.content;
+  let { collection: t, document: i } = Yt(n.createCollection);
+  return /* @__PURE__ */ $.createElement($.Fragment, null, /* @__PURE__ */ $.createElement(mt, null, /* @__PURE__ */ $.createElement(Z.Provider, {
+    value: i
+  }, n.content)), /* @__PURE__ */ $.createElement(Gt, {
+    render: n.children,
+    collection: t
+  }));
+}
+function Gt({ collection: n, render: e }) {
+  return e(n);
+}
+function Wt(n, e, t) {
+  let i = je(), l = E(i);
+  l.current = i;
+  let r = X(() => l.current ? t() : e(), [
+    e,
+    t
+  ]);
+  return Vt.useSyncExternalStore(n, r);
+}
+const jt = typeof $.useSyncExternalStore == "function" ? $.useSyncExternalStore : Wt;
+function Yt(n) {
+  let [e] = ie(() => new qt(n?.() || new _t())), t = X((s) => e.subscribe(s), [
+    e
+  ]), i = X(() => {
+    let s = e.getCollection();
+    return e.isSSR && e.resetAfterSSR(), s;
+  }, [
+    e
+  ]), l = X(() => (e.isSSR = !0, e.getCollection()), [
+    e
+  ]), r = jt(t, i, l);
+  return me(() => (e.isMounted = !0, () => {
+    e.isMounted = !1;
+  }), [
+    e
+  ]), {
+    collection: r,
+    document: e
+  };
+}
+const Ke = /* @__PURE__ */ z(null);
+function Xt(n) {
+  var e;
+  return e = class extends ne {
+  }, e.type = n, e;
+}
+function lt(n, e, t, i, l, r) {
+  typeof n == "string" && (n = Xt(n));
+  let s = X((u) => {
+    u?.setProps(e, t, n, i, r);
+  }, [
+    e,
+    t,
+    i,
+    r,
+    n
+  ]), c = _(Ke);
+  if (c) {
+    let u = c.ownerDocument.nodesByProps.get(e);
+    return u || (u = c.ownerDocument.createElement(n.type), u.setProps(e, t, n, i, r), c.appendChild(u), c.ownerDocument.updateCollection(), c.ownerDocument.nodesByProps.set(e, u)), l ? /* @__PURE__ */ $.createElement(Ke.Provider, {
+      value: u
+    }, l) : null;
+  }
+  return /* @__PURE__ */ $.createElement(n.type, {
+    ref: s
+  }, l);
+}
+function ki(n, e) {
+  let t = ({ node: l }) => e(l.props, l.props.ref, l), i = He((l, r) => {
+    let s = _(ke);
+    if (!_(it)) {
+      if (e.length >= 3) throw new Error(e.name + " cannot be rendered outside a collection.");
+      return e(l, r);
+    }
+    return lt(n, l, r, "children" in l ? l.children : null, null, (u) => (
+      // Forward FocusableContext to real DOM tree so tooltips work.
+      /* @__PURE__ */ $.createElement(ke.Provider, {
+        value: s
+      }, /* @__PURE__ */ $.createElement(t, {
+        node: u
+      }))
+    ));
+  });
+  return i.displayName = e.name, i;
+}
+function Ii(n, e, t = nt) {
+  let i = ({ node: r }) => e(r.props, r.props.ref, r), l = He((r, s) => {
+    let c = t(r);
+    var u;
+    return (u = lt(n, r, s, null, c, (h) => /* @__PURE__ */ $.createElement(i, {
+      node: h
+    }))) !== null && u !== void 0 ? u : /* @__PURE__ */ $.createElement($.Fragment, null);
+  });
+  return l.displayName = e.name, l;
+}
+function nt(n) {
+  return tt({
+    ...n,
+    addIdAndValue: !0
+  });
+}
+const Be = /* @__PURE__ */ z(null);
+function Pi(n) {
+  let e = _(Be), t = (e?.dependencies || []).concat(n.dependencies), i = n.idScope || e?.idScope, l = nt({
+    ...n,
+    idScope: i,
+    dependencies: t
+  });
+  return _(Z) && (l = /* @__PURE__ */ $.createElement(Jt, null, l)), e = B(() => ({
+    dependencies: t,
+    idScope: i
+  }), [
+    i,
+    ...t
+  ]), /* @__PURE__ */ $.createElement(Be.Provider, {
+    value: e
+  }, l);
+}
+function Jt({ children: n }) {
+  let e = _(Z), t = B(() => /* @__PURE__ */ $.createElement(Z.Provider, {
+    value: null
+  }, /* @__PURE__ */ $.createElement(it.Provider, {
+    value: !0
+  }, n)), [
+    n
+  ]);
+  return je() ? /* @__PURE__ */ $.createElement(Ke.Provider, {
+    value: e
+  }, t) : /* @__PURE__ */ ht(t, e);
+}
+const Fi = /* @__PURE__ */ z(null), Zt = {
+  CollectionRoot({ collection: n, renderDropIndicator: e }) {
+    return Ve(n, null, e);
+  },
+  CollectionBranch({ collection: n, parent: e, renderDropIndicator: t }) {
+    return Ve(n, e, t);
+  }
+};
+function Ve(n, e, t) {
+  return tt({
+    items: e ? n.getChildren(e.key) : n,
+    dependencies: [
+      t
+    ],
+    children(i) {
+      let l = i.render(i);
+      return !t || i.type !== "item" ? l : /* @__PURE__ */ $.createElement($.Fragment, null, t({
+        type: "item",
+        key: i.key,
+        dropPosition: "before"
+      }), l, Qt(n, i, t));
+    }
+  });
+}
+function Qt(n, e, t) {
+  let i = e.key, l = n.getKeyAfter(i), r = l != null ? n.getItem(l) : null;
+  for (; r != null && r.type !== "item"; )
+    l = n.getKeyAfter(r.key), r = l != null ? n.getItem(l) : null;
+  let s = e.nextKey != null ? n.getItem(e.nextKey) : null;
+  for (; s != null && s.type !== "item"; ) s = s.nextKey != null ? n.getItem(s.nextKey) : null;
+  let c = [];
+  if (s == null) {
+    let u = e;
+    for (; u && (!r || u.parentKey !== r.parentKey && r.level < u.level); ) {
+      let h = t({
+        type: "item",
+        key: u.key,
+        dropPosition: "after"
+      });
+      /* @__PURE__ */ st(h) && c.push(/* @__PURE__ */ ze(h, {
+        key: `${u.key}-after`
+      })), u = u.parentKey != null ? n.getItem(u.parentKey) : null;
+    }
+  }
+  return c;
+}
+const Mi = /* @__PURE__ */ z(Zt);
+function Ai(n) {
+  return B(() => n != null ? /* @__PURE__ */ new Set([
+    n
+  ]) : null, [
+    n
+  ]);
+}
+class R extends Set {
+  constructor(e, t, i) {
+    super(e), e instanceof R ? (this.anchorKey = t ?? e.anchorKey, this.currentKey = i ?? e.currentKey) : (this.anchorKey = t ?? null, this.currentKey = i ?? null);
+  }
+}
+function ei(n, e) {
+  if (n.size !== e.size) return !1;
+  for (let t of n)
+    if (!e.has(t)) return !1;
+  return !0;
+}
+function Ri(n) {
+  let { selectionMode: e = "none", disallowEmptySelection: t = !1, allowDuplicateSelectionEvents: i, selectionBehavior: l = "toggle", disabledBehavior: r = "all" } = n, s = E(!1), [, c] = ie(!1), u = E(null), h = E(null), [, b] = ie(null), d = B(() => Ne(n.selectedKeys), [
+    n.selectedKeys
+  ]), f = B(() => Ne(n.defaultSelectedKeys, new R()), [
+    n.defaultSelectedKeys
+  ]), [y, v] = bt(d, f, n.onSelectionChange), K = B(() => n.disabledKeys ? new Set(n.disabledKeys) : /* @__PURE__ */ new Set(), [
+    n.disabledKeys
+  ]), [g, m] = ie(l);
+  l === "replace" && g === "toggle" && typeof y == "object" && y.size === 0 && m("replace");
+  let w = E(l);
+  return Y(() => {
+    l !== w.current && (m(l), w.current = l);
+  }, [
+    l
+  ]), {
+    selectionMode: e,
+    disallowEmptySelection: t,
+    selectionBehavior: g,
+    setSelectionBehavior: m,
+    get isFocused() {
+      return s.current;
+    },
+    setFocused(x) {
+      s.current = x, c(x);
+    },
+    get focusedKey() {
+      return u.current;
+    },
+    get childFocusStrategy() {
+      return h.current;
+    },
+    setFocusedKey(x, k = "first") {
+      u.current = x, h.current = k, b(x);
+    },
+    selectedKeys: y,
+    setSelectedKeys(x) {
+      (i || !ei(x, y)) && v(x);
+    },
+    disabledKeys: K,
+    disabledBehavior: r
+  };
+}
+function Ne(n, e) {
+  return n ? n === "all" ? "all" : new R(n) : e;
+}
+class rt {
+  /**
+  * The type of selection that is allowed in the collection.
+  */
+  get selectionMode() {
+    return this.state.selectionMode;
+  }
+  /**
+  * Whether the collection allows empty selection.
+  */
+  get disallowEmptySelection() {
+    return this.state.disallowEmptySelection;
+  }
+  /**
+  * The selection behavior for the collection.
+  */
+  get selectionBehavior() {
+    return this.state.selectionBehavior;
+  }
+  /**
+  * Sets the selection behavior for the collection.
+  */
+  setSelectionBehavior(e) {
+    this.state.setSelectionBehavior(e);
+  }
+  /**
+  * Whether the collection is currently focused.
+  */
+  get isFocused() {
+    return this.state.isFocused;
+  }
+  /**
+  * Sets whether the collection is focused.
+  */
+  setFocused(e) {
+    this.state.setFocused(e);
+  }
+  /**
+  * The current focused key in the collection.
+  */
+  get focusedKey() {
+    return this.state.focusedKey;
+  }
+  /** Whether the first or last child of the focused key should receive focus. */
+  get childFocusStrategy() {
+    return this.state.childFocusStrategy;
+  }
+  /**
+  * Sets the focused key.
+  */
+  setFocusedKey(e, t) {
+    (e == null || this.collection.getItem(e)) && this.state.setFocusedKey(e, t);
+  }
+  /**
+  * The currently selected keys in the collection.
+  */
+  get selectedKeys() {
+    return this.state.selectedKeys === "all" ? new Set(this.getSelectAllKeys()) : this.state.selectedKeys;
+  }
+  /**
+  * The raw selection value for the collection.
+  * Either 'all' for select all, or a set of keys.
+  */
+  get rawSelection() {
+    return this.state.selectedKeys;
+  }
+  /**
+  * Returns whether a key is selected.
+  */
+  isSelected(e) {
+    if (this.state.selectionMode === "none") return !1;
+    let t = this.getKey(e);
+    return t == null ? !1 : this.state.selectedKeys === "all" ? this.canSelectItem(t) : this.state.selectedKeys.has(t);
+  }
+  /**
+  * Whether the selection is empty.
+  */
+  get isEmpty() {
+    return this.state.selectedKeys !== "all" && this.state.selectedKeys.size === 0;
+  }
+  /**
+  * Whether all items in the collection are selected.
+  */
+  get isSelectAll() {
+    if (this.isEmpty) return !1;
+    if (this.state.selectedKeys === "all") return !0;
+    if (this._isSelectAll != null) return this._isSelectAll;
+    let e = this.getSelectAllKeys(), t = this.state.selectedKeys;
+    return this._isSelectAll = e.every((i) => t.has(i)), this._isSelectAll;
+  }
+  get firstSelectedKey() {
+    let e = null;
+    for (let i of this.state.selectedKeys) {
+      let l = this.collection.getItem(i);
+      (!e || l && pe(this.collection, l, e) < 0) && (e = l);
+    }
+    var t;
+    return (t = e?.key) !== null && t !== void 0 ? t : null;
+  }
+  get lastSelectedKey() {
+    let e = null;
+    for (let i of this.state.selectedKeys) {
+      let l = this.collection.getItem(i);
+      (!e || l && pe(this.collection, l, e) > 0) && (e = l);
+    }
+    var t;
+    return (t = e?.key) !== null && t !== void 0 ? t : null;
+  }
+  get disabledKeys() {
+    return this.state.disabledKeys;
+  }
+  get disabledBehavior() {
+    return this.state.disabledBehavior;
+  }
+  /**
+  * Extends the selection to the given key.
+  */
+  extendSelection(e) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      this.replaceSelection(e);
+      return;
+    }
+    let t = this.getKey(e);
+    if (t == null) return;
+    let i;
+    if (this.state.selectedKeys === "all") i = new R([
+      t
+    ], t, t);
+    else {
+      let s = this.state.selectedKeys;
+      var l;
+      let c = (l = s.anchorKey) !== null && l !== void 0 ? l : t;
+      i = new R(s, c, t);
+      var r;
+      for (let u of this.getKeyRange(c, (r = s.currentKey) !== null && r !== void 0 ? r : t)) i.delete(u);
+      for (let u of this.getKeyRange(t, c)) this.canSelectItem(u) && i.add(u);
+    }
+    this.state.setSelectedKeys(i);
+  }
+  getKeyRange(e, t) {
+    let i = this.collection.getItem(e), l = this.collection.getItem(t);
+    return i && l ? pe(this.collection, i, l) <= 0 ? this.getKeyRangeInternal(e, t) : this.getKeyRangeInternal(t, e) : [];
+  }
+  getKeyRangeInternal(e, t) {
+    var i;
+    if (!((i = this.layoutDelegate) === null || i === void 0) && i.getKeyRange) return this.layoutDelegate.getKeyRange(e, t);
+    let l = [], r = e;
+    for (; r != null; ) {
+      let s = this.collection.getItem(r);
+      if (s && (s.type === "item" || s.type === "cell" && this.allowsCellSelection) && l.push(r), r === t) return l;
+      r = this.collection.getKeyAfter(r);
+    }
+    return [];
+  }
+  getKey(e) {
+    let t = this.collection.getItem(e);
+    if (!t || t.type === "cell" && this.allowsCellSelection) return e;
+    for (; t && t.type !== "item" && t.parentKey != null; ) t = this.collection.getItem(t.parentKey);
+    return !t || t.type !== "item" ? null : t.key;
+  }
+  /**
+  * Toggles whether the given key is selected.
+  */
+  toggleSelection(e) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single" && !this.isSelected(e)) {
+      this.replaceSelection(e);
+      return;
+    }
+    let t = this.getKey(e);
+    if (t == null) return;
+    let i = new R(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+    i.has(t) ? i.delete(t) : this.canSelectItem(t) && (i.add(t), i.anchorKey = t, i.currentKey = t), !(this.disallowEmptySelection && i.size === 0) && this.state.setSelectedKeys(i);
+  }
+  /**
+  * Replaces the selection with only the given key.
+  */
+  replaceSelection(e) {
+    if (this.selectionMode === "none") return;
+    let t = this.getKey(e);
+    if (t == null) return;
+    let i = this.canSelectItem(t) ? new R([
+      t
+    ], t, t) : new R();
+    this.state.setSelectedKeys(i);
+  }
+  /**
+  * Replaces the selection with the given keys.
+  */
+  setSelectedKeys(e) {
+    if (this.selectionMode === "none") return;
+    let t = new R();
+    for (let i of e) {
+      let l = this.getKey(i);
+      if (l != null && (t.add(l), this.selectionMode === "single"))
+        break;
+    }
+    this.state.setSelectedKeys(t);
+  }
+  getSelectAllKeys() {
+    let e = [], t = (i) => {
+      for (; i != null; ) {
+        if (this.canSelectItem(i)) {
+          var l;
+          let s = this.collection.getItem(i);
+          s?.type === "item" && e.push(i);
+          var r;
+          s?.hasChildNodes && (this.allowsCellSelection || s.type !== "item") && t((r = (l = Rt(At(s, this.collection))) === null || l === void 0 ? void 0 : l.key) !== null && r !== void 0 ? r : null);
+        }
+        i = this.collection.getKeyAfter(i);
+      }
+    };
+    return t(this.collection.getFirstKey()), e;
+  }
+  /**
+  * Selects all items in the collection.
+  */
+  selectAll() {
+    !this.isSelectAll && this.selectionMode === "multiple" && this.state.setSelectedKeys("all");
+  }
+  /**
+  * Removes all keys from the selection.
+  */
+  clearSelection() {
+    !this.disallowEmptySelection && (this.state.selectedKeys === "all" || this.state.selectedKeys.size > 0) && this.state.setSelectedKeys(new R());
+  }
+  /**
+  * Toggles between select all and an empty selection.
+  */
+  toggleSelectAll() {
+    this.isSelectAll ? this.clearSelection() : this.selectAll();
+  }
+  select(e, t) {
+    this.selectionMode !== "none" && (this.selectionMode === "single" ? this.isSelected(e) && !this.disallowEmptySelection ? this.toggleSelection(e) : this.replaceSelection(e) : this.selectionBehavior === "toggle" || t && (t.pointerType === "touch" || t.pointerType === "virtual") ? this.toggleSelection(e) : this.replaceSelection(e));
+  }
+  /**
+  * Returns whether the current selection is equal to the given selection.
+  */
+  isSelectionEqual(e) {
+    if (e === this.state.selectedKeys) return !0;
+    let t = this.selectedKeys;
+    if (e.size !== t.size) return !1;
+    for (let i of e)
+      if (!t.has(i)) return !1;
+    for (let i of t)
+      if (!e.has(i)) return !1;
+    return !0;
+  }
+  canSelectItem(e) {
+    var t;
+    if (this.state.selectionMode === "none" || this.state.disabledKeys.has(e)) return !1;
+    let i = this.collection.getItem(e);
+    return !(!i || !(i == null || (t = i.props) === null || t === void 0) && t.isDisabled || i.type === "cell" && !this.allowsCellSelection);
+  }
+  isDisabled(e) {
+    var t, i;
+    return this.state.disabledBehavior === "all" && (this.state.disabledKeys.has(e) || !!(!((i = this.collection.getItem(e)) === null || i === void 0 || (t = i.props) === null || t === void 0) && t.isDisabled));
+  }
+  isLink(e) {
+    var t, i;
+    return !!(!((i = this.collection.getItem(e)) === null || i === void 0 || (t = i.props) === null || t === void 0) && t.href);
+  }
+  getItemProps(e) {
+    var t;
+    return (t = this.collection.getItem(e)) === null || t === void 0 ? void 0 : t.props;
+  }
+  withCollection(e) {
+    return new rt(e, this.state, {
+      allowsCellSelection: this.allowsCellSelection,
+      layoutDelegate: this.layoutDelegate || void 0
+    });
+  }
+  constructor(e, t, i) {
+    this.collection = e, this.state = t;
+    var l;
+    this.allowsCellSelection = (l = i?.allowsCellSelection) !== null && l !== void 0 ? l : !1, this._isSelectAll = null, this.layoutDelegate = i?.layoutDelegate || null;
+  }
+}
+export {
+  Ki as $,
+  _t as A,
+  Di as B,
+  Ze as C,
+  Xe as D,
+  $t as E,
+  Ye as F,
+  St as G,
+  wt as H,
+  q as I,
+  Ct as J,
+  xt as K,
+  Si as a,
+  At as b,
+  ki as c,
+  Nt as d,
+  ne as e,
+  $i as f,
+  Ri as g,
+  xi as h,
+  rt as i,
+  Ii as j,
+  Ht as k,
+  Ut as l,
+  Ei as m,
+  Pi as n,
+  Mi as o,
+  Ci as p,
+  Fi as q,
+  zt as r,
+  It as s,
+  Zt as t,
+  Ai as u,
+  wi as v,
+  Rt as w,
+  Tt as x,
+  Me as y,
+  tt as z
+};
+//# sourceMappingURL=SelectionManager-CLyu96pU.es.js.map