@commercetools/nimbus 0.0.0-canary-20250903194502 → 0.0.0-canary-20250904053156

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

@@ -0,0 +1,1267 @@
+import L, { useRef as w, useEffect as j, useMemo as W, createContext as Q, isValidElement as Me, cloneElement as Le, useState as oe } from "react";
+import { a as Pe, d as Te } from "./utils-jpfA6kxk.es.js";
+import { c as ye, $ as Y, a as Ie, d as pe, e as Oe } from "./mergeProps-B_9syxhT.es.js";
+import { $ as ae } from "./focusWithoutScrolling-CDw3JYiq.es.js";
+import { $ as Ee, d as ze } from "./openLink-Ctl0AdAy.es.js";
+import { $ as Z } from "./useEvent-YHhqZvpU.es.js";
+import { a as Ve, b as Ue, c as ve, d as ge } from "./scrollIntoView-BYF_8_6g.es.js";
+import { b as He } from "./FocusScope-CNO0fzPs.es.js";
+import { b as be } from "./useFocusVisible-CWDaG0ze.es.js";
+import { $ as fe } from "./focusSafely-DJpphVHF.es.js";
+import { flushSync as We } from "react-dom";
+import { $ as qe } from "./context-R4YUlO9Y.es.js";
+import { b as Ge, g as je } from "./platform-Z5fvtFmM.es.js";
+import { $ as ke } from "./usePress-DHhWHfMz.es.js";
+import { $ as Ye } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { j as Xe } from "./Separator-BCuq0iz5.es.js";
+import { $ as Ze } from "./useControlledState-u436Wbp1.es.js";
+function me(n, e) {
+  const t = w(!0), l = w(null);
+  ye(() => (t.current = !0, () => {
+    t.current = !1;
+  }), []), ye(() => {
+    t.current ? t.current = !1 : (!l.current || e.some((i, s) => !Object.is(i, l[s]))) && n(), l.current = e;
+  }, e);
+}
+const Je = "react-aria-clear-focus", Qe = "react-aria-focus";
+function H(n) {
+  return Ge() ? n.metaKey : n.ctrlKey;
+}
+const Ne = 500;
+function _e(n) {
+  let { isDisabled: e, onLongPressStart: t, onLongPressEnd: l, onLongPress: i, threshold: s = Ne, accessibilityDescription: o } = n;
+  const f = w(void 0);
+  let { addGlobalListener: a, removeGlobalListener: $ } = Ye(), { pressProps: I } = ke({
+    isDisabled: e,
+    onPressStart(v) {
+      if (v.continuePropagation(), (v.pointerType === "mouse" || v.pointerType === "touch") && (t && t({
+        ...v,
+        type: "longpressstart"
+      }), f.current = setTimeout(() => {
+        v.target.dispatchEvent(new PointerEvent("pointercancel", {
+          bubbles: !0
+        })), Pe(v.target).activeElement !== v.target && ae(v.target), i && i({
+          ...v,
+          type: "longpress"
+        }), f.current = void 0;
+      }, s), v.pointerType === "touch")) {
+        let m = (g) => {
+          g.preventDefault();
+        };
+        a(v.target, "contextmenu", m, {
+          once: !0
+        }), a(window, "pointerup", () => {
+          setTimeout(() => {
+            $(v.target, "contextmenu", m);
+          }, 30);
+        }, {
+          once: !0
+        });
+      }
+    },
+    onPressEnd(v) {
+      f.current && clearTimeout(f.current), l && (v.pointerType === "mouse" || v.pointerType === "touch") && l({
+        ...v,
+        type: "longpressend"
+      });
+    }
+  }), b = Ve(i && !e ? o : void 0);
+  return {
+    longPressProps: Y(I, b)
+  };
+}
+function Ae(n) {
+  let e = tt(Pe(n));
+  e !== n && (e && et(e, n), n && Ce(n, e));
+}
+function et(n, e) {
+  n.dispatchEvent(new FocusEvent("blur", {
+    relatedTarget: e
+  })), n.dispatchEvent(new FocusEvent("focusout", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function Ce(n, e) {
+  n.dispatchEvent(new FocusEvent("focus", {
+    relatedTarget: e
+  })), n.dispatchEvent(new FocusEvent("focusin", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function tt(n) {
+  let e = Te(n), t = e?.getAttribute("aria-activedescendant");
+  return t && n.getElementById(t) || e;
+}
+function de(n) {
+  return je() ? n.altKey : n.ctrlKey;
+}
+function J(n, e) {
+  var t, l;
+  let i = `[data-key="${CSS.escape(String(e))}"]`, s = (t = n.current) === null || t === void 0 ? void 0 : t.dataset.collection;
+  return s && (i = `[data-collection="${CSS.escape(s)}"]${i}`), (l = n.current) === null || l === void 0 ? void 0 : l.querySelector(i);
+}
+const Re = /* @__PURE__ */ new WeakMap();
+function lt(n) {
+  let e = Ie();
+  return Re.set(n, e), e;
+}
+function it(n) {
+  return Re.get(n);
+}
+const nt = 1e3;
+function rt(n) {
+  let { keyboardDelegate: e, selectionManager: t, onTypeSelect: l } = n, i = w({
+    search: "",
+    timeout: void 0
+  }).current, s = (o) => {
+    let f = st(o.key);
+    if (!(!f || o.ctrlKey || o.metaKey || !o.currentTarget.contains(o.target) || i.search.length === 0 && f === " ")) {
+      if (f === " " && i.search.trim().length > 0 && (o.preventDefault(), "continuePropagation" in o || o.stopPropagation()), i.search += f, e.getKeyForSearch != null) {
+        let a = e.getKeyForSearch(i.search, t.focusedKey);
+        a == null && (a = e.getKeyForSearch(i.search)), a != null && (t.setFocusedKey(a), l && l(a));
+      }
+      clearTimeout(i.timeout), i.timeout = setTimeout(() => {
+        i.search = "";
+      }, nt);
+    }
+  };
+  return {
+    typeSelectProps: {
+      // Using a capturing listener to catch the keydown event before
+      // other hooks in order to handle the Spacebar event.
+      onKeyDownCapture: e.getKeyForSearch ? s : void 0
+    }
+  };
+}
+function st(n) {
+  return n.length === 1 || !/^[A-Z]/i.test(n) ? n : "";
+}
+function At(n) {
+  let { selectionManager: e, keyboardDelegate: t, ref: l, autoFocus: i = !1, shouldFocusWrap: s = !1, disallowEmptySelection: o = !1, disallowSelectAll: f = !1, escapeKeyBehavior: a = "clearSelection", selectOnFocus: $ = e.selectionBehavior === "replace", disallowTypeAhead: I = !1, shouldUseVirtualFocus: b, allowsTabNavigation: v = !1, isVirtualized: m, scrollRef: g = l, linkBehavior: E = "action" } = n, { direction: y } = qe(), h = Ee(), S = (c) => {
+    var d;
+    if (c.altKey && c.key === "Tab" && c.preventDefault(), !(!((d = l.current) === null || d === void 0) && d.contains(c.target))) return;
+    const r = (u, V) => {
+      if (u != null) {
+        if (e.isLink(u) && E === "selection" && $ && !de(c)) {
+          We(() => {
+            e.setFocusedKey(u, V);
+          });
+          let U = J(l, u), he = e.getItemProps(u);
+          U && h.open(U, c, he.href, he.routerOptions);
+          return;
+        }
+        if (e.setFocusedKey(u, V), e.isLink(u) && E === "override") return;
+        c.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(u) : $ && !de(c) && e.replaceSelection(u);
+      }
+    };
+    switch (c.key) {
+      case "ArrowDown":
+        if (t.getKeyBelow) {
+          var K, T, P;
+          let u = e.focusedKey != null ? (K = t.getKeyBelow) === null || K === void 0 ? void 0 : K.call(t, e.focusedKey) : (T = t.getFirstKey) === null || T === void 0 ? void 0 : T.call(t);
+          u == null && s && (u = (P = t.getFirstKey) === null || P === void 0 ? void 0 : P.call(t, e.focusedKey)), u != null && (c.preventDefault(), r(u));
+        }
+        break;
+      case "ArrowUp":
+        if (t.getKeyAbove) {
+          var M, z, ee;
+          let u = e.focusedKey != null ? (M = t.getKeyAbove) === null || M === void 0 ? void 0 : M.call(t, e.focusedKey) : (z = t.getLastKey) === null || z === void 0 ? void 0 : z.call(t);
+          u == null && s && (u = (ee = t.getLastKey) === null || ee === void 0 ? void 0 : ee.call(t, e.focusedKey)), u != null && (c.preventDefault(), r(u));
+        }
+        break;
+      case "ArrowLeft":
+        if (t.getKeyLeftOf) {
+          var te, le, ie;
+          let u = e.focusedKey != null ? (te = t.getKeyLeftOf) === null || te === void 0 ? void 0 : te.call(t, e.focusedKey) : null;
+          u == null && s && (u = y === "rtl" ? (le = t.getFirstKey) === null || le === void 0 ? void 0 : le.call(t, e.focusedKey) : (ie = t.getLastKey) === null || ie === void 0 ? void 0 : ie.call(t, e.focusedKey)), u != null && (c.preventDefault(), r(u, y === "rtl" ? "first" : "last"));
+        }
+        break;
+      case "ArrowRight":
+        if (t.getKeyRightOf) {
+          var ne, re, se;
+          let u = e.focusedKey != null ? (ne = t.getKeyRightOf) === null || ne === void 0 ? void 0 : ne.call(t, e.focusedKey) : null;
+          u == null && s && (u = y === "rtl" ? (re = t.getLastKey) === null || re === void 0 ? void 0 : re.call(t, e.focusedKey) : (se = t.getFirstKey) === null || se === void 0 ? void 0 : se.call(t, e.focusedKey)), u != null && (c.preventDefault(), r(u, y === "rtl" ? "last" : "first"));
+        }
+        break;
+      case "Home":
+        if (t.getFirstKey) {
+          if (e.focusedKey === null && c.shiftKey) return;
+          c.preventDefault();
+          let u = t.getFirstKey(e.focusedKey, H(c));
+          e.setFocusedKey(u), u != null && (H(c) && c.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(u) : $ && e.replaceSelection(u));
+        }
+        break;
+      case "End":
+        if (t.getLastKey) {
+          if (e.focusedKey === null && c.shiftKey) return;
+          c.preventDefault();
+          let u = t.getLastKey(e.focusedKey, H(c));
+          e.setFocusedKey(u), u != null && (H(c) && c.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(u) : $ && e.replaceSelection(u));
+        }
+        break;
+      case "PageDown":
+        if (t.getKeyPageBelow && e.focusedKey != null) {
+          let u = t.getKeyPageBelow(e.focusedKey);
+          u != null && (c.preventDefault(), r(u));
+        }
+        break;
+      case "PageUp":
+        if (t.getKeyPageAbove && e.focusedKey != null) {
+          let u = t.getKeyPageAbove(e.focusedKey);
+          u != null && (c.preventDefault(), r(u));
+        }
+        break;
+      case "a":
+        H(c) && e.selectionMode === "multiple" && f !== !0 && (c.preventDefault(), e.selectAll());
+        break;
+      case "Escape":
+        a === "clearSelection" && !o && e.selectedKeys.size !== 0 && (c.stopPropagation(), c.preventDefault(), e.clearSelection());
+        break;
+      case "Tab":
+        if (!v) {
+          if (c.shiftKey) l.current.focus();
+          else {
+            let u = He(l.current, {
+              tabbable: !0
+            }), V, U;
+            do
+              U = u.lastChild(), U && (V = U);
+            while (U);
+            V && !V.contains(document.activeElement) && ae(V);
+          }
+          break;
+        }
+    }
+  }, p = w({
+    top: 0,
+    left: 0
+  });
+  Z(g, "scroll", m ? void 0 : () => {
+    var c, d, r, K;
+    p.current = {
+      top: (r = (c = g.current) === null || c === void 0 ? void 0 : c.scrollTop) !== null && r !== void 0 ? r : 0,
+      left: (K = (d = g.current) === null || d === void 0 ? void 0 : d.scrollLeft) !== null && K !== void 0 ? K : 0
+    };
+  });
+  let D = (c) => {
+    if (e.isFocused) {
+      c.currentTarget.contains(c.target) || e.setFocused(!1);
+      return;
+    }
+    if (c.currentTarget.contains(c.target)) {
+      if (e.setFocused(!0), e.focusedKey == null) {
+        var d, r;
+        let P = (z) => {
+          z != null && (e.setFocusedKey(z), $ && !e.isSelected(z) && e.replaceSelection(z));
+        }, M = c.relatedTarget;
+        var K, T;
+        M && c.currentTarget.compareDocumentPosition(M) & Node.DOCUMENT_POSITION_FOLLOWING ? P((K = e.lastSelectedKey) !== null && K !== void 0 ? K : (d = t.getLastKey) === null || d === void 0 ? void 0 : d.call(t)) : P((T = e.firstSelectedKey) !== null && T !== void 0 ? T : (r = t.getFirstKey) === null || r === void 0 ? void 0 : r.call(t));
+      } else !m && g.current && (g.current.scrollTop = p.current.top, g.current.scrollLeft = p.current.left);
+      if (e.focusedKey != null && g.current) {
+        let P = J(l, e.focusedKey);
+        P instanceof HTMLElement && (!P.contains(document.activeElement) && !b && ae(P), be() === "keyboard" && ve(P, {
+          containingElement: l.current
+        }));
+      }
+    }
+  }, k = (c) => {
+    c.currentTarget.contains(c.relatedTarget) || e.setFocused(!1);
+  }, A = w(!1);
+  Z(l, Qe, b ? (c) => {
+    let { detail: d } = c;
+    c.stopPropagation(), e.setFocused(!0), d?.focusStrategy === "first" && (A.current = !0);
+  } : void 0);
+  let R = pe(() => {
+    var c, d;
+    let r = (d = (c = t.getFirstKey) === null || c === void 0 ? void 0 : c.call(t)) !== null && d !== void 0 ? d : null;
+    if (r == null) {
+      let K = Te();
+      Ae(l.current), Ce(K, null), e.collection.size > 0 && (A.current = !1);
+    } else
+      e.setFocusedKey(r), A.current = !1;
+  });
+  me(() => {
+    A.current && R();
+  }, [
+    e.collection,
+    R
+  ]);
+  let F = pe(() => {
+    e.collection.size > 0 && (A.current = !1);
+  });
+  me(() => {
+    F();
+  }, [
+    e.focusedKey,
+    F
+  ]), Z(l, Je, b ? (c) => {
+    var d;
+    c.stopPropagation(), e.setFocused(!1), !((d = c.detail) === null || d === void 0) && d.clearFocusKey && e.setFocusedKey(null);
+  } : void 0);
+  const q = w(i), B = w(!1);
+  j(() => {
+    if (q.current) {
+      var c, d;
+      let T = null;
+      var r;
+      i === "first" && (T = (r = (c = t.getFirstKey) === null || c === void 0 ? void 0 : c.call(t)) !== null && r !== void 0 ? r : null);
+      var K;
+      i === "last" && (T = (K = (d = t.getLastKey) === null || d === void 0 ? void 0 : d.call(t)) !== null && K !== void 0 ? K : null);
+      let P = e.selectedKeys;
+      if (P.size) {
+        for (let M of P) if (e.canSelectItem(M)) {
+          T = M;
+          break;
+        }
+      }
+      e.setFocused(!0), e.setFocusedKey(T), T == null && !b && l.current && fe(l.current), e.collection.size > 0 && (q.current = !1, B.current = !0);
+    }
+  });
+  let O = w(e.focusedKey), x = w(null);
+  j(() => {
+    if (e.isFocused && e.focusedKey != null && (e.focusedKey !== O.current || B.current) && g.current && l.current) {
+      let c = be(), d = J(l, e.focusedKey);
+      if (!(d instanceof HTMLElement))
+        return;
+      (c === "keyboard" || B.current) && (x.current && cancelAnimationFrame(x.current), x.current = requestAnimationFrame(() => {
+        g.current && (Ue(g.current, d), c !== "virtual" && ve(d, {
+          containingElement: l.current
+        }));
+      }));
+    }
+    !b && e.isFocused && e.focusedKey == null && O.current != null && l.current && fe(l.current), O.current = e.focusedKey, B.current = !1;
+  }), j(() => () => {
+    x.current && cancelAnimationFrame(x.current);
+  }, []), Z(l, "react-aria-focus-scope-restore", (c) => {
+    c.preventDefault(), e.setFocused(!0);
+  });
+  let G = {
+    onKeyDown: S,
+    onFocus: D,
+    onBlur: k,
+    onMouseDown(c) {
+      g.current === c.target && c.preventDefault();
+    }
+  }, { typeSelectProps: N } = rt({
+    keyboardDelegate: t,
+    selectionManager: e
+  });
+  I || (G = Y(N, G));
+  let X;
+  b || (X = e.focusedKey == null ? 0 : -1);
+  let _ = lt(e.collection);
+  return {
+    collectionProps: Y(G, {
+      tabIndex: X,
+      "data-collection": _
+    })
+  };
+}
+function Ct(n) {
+  let { id: e, selectionManager: t, key: l, ref: i, shouldSelectOnPressUp: s, shouldUseVirtualFocus: o, focus: f, isDisabled: a, onAction: $, allowsDifferentPressOrigin: I, linkBehavior: b = "action" } = n, v = Ee();
+  e = Ie(e);
+  let m = (r) => {
+    if (r.pointerType === "keyboard" && de(r)) t.toggleSelection(l);
+    else {
+      if (t.selectionMode === "none") return;
+      if (t.isLink(l)) {
+        if (b === "selection" && i.current) {
+          let K = t.getItemProps(l);
+          v.open(i.current, r, K.href, K.routerOptions), t.setSelectedKeys(t.selectedKeys);
+          return;
+        } else if (b === "override" || b === "none") return;
+      }
+      t.selectionMode === "single" ? t.isSelected(l) && !t.disallowEmptySelection ? t.toggleSelection(l) : t.replaceSelection(l) : r && r.shiftKey ? t.extendSelection(l) : t.selectionBehavior === "toggle" || r && (H(r) || r.pointerType === "touch" || r.pointerType === "virtual") ? t.toggleSelection(l) : t.replaceSelection(l);
+    }
+  };
+  j(() => {
+    l === t.focusedKey && t.isFocused && (o ? Ae(i.current) : f ? f() : document.activeElement !== i.current && i.current && fe(i.current));
+  }, [
+    i,
+    l,
+    t.focusedKey,
+    t.childFocusStrategy,
+    t.isFocused,
+    o
+  ]), a = a || t.isDisabled(l);
+  let g = {};
+  !o && !a ? g = {
+    tabIndex: l === t.focusedKey ? 0 : -1,
+    onFocus(r) {
+      r.target === i.current && t.setFocusedKey(l);
+    }
+  } : a && (g.onMouseDown = (r) => {
+    r.preventDefault();
+  });
+  let E = t.isLink(l) && b === "override", y = t.isLink(l) && b !== "selection" && b !== "none", h = !a && t.canSelectItem(l) && !E, S = ($ || y) && !a, p = S && (t.selectionBehavior === "replace" ? !h : !h || t.isEmpty), D = S && h && t.selectionBehavior === "replace", k = p || D, A = w(null), R = k && h, F = w(!1), q = w(!1), B = t.getItemProps(l), O = (r) => {
+    $ && $(), y && i.current && v.open(i.current, r, B.href, B.routerOptions);
+  }, x = {
+    ref: i
+  };
+  if (s ? (x.onPressStart = (r) => {
+    A.current = r.pointerType, F.current = R, r.pointerType === "keyboard" && (!k || Ke()) && m(r);
+  }, I ? (x.onPressUp = p ? void 0 : (r) => {
+    r.pointerType === "mouse" && h && m(r);
+  }, x.onPress = p ? O : (r) => {
+    r.pointerType !== "keyboard" && r.pointerType !== "mouse" && h && m(r);
+  }) : x.onPress = (r) => {
+    if (p || D && r.pointerType !== "mouse") {
+      if (r.pointerType === "keyboard" && !$e()) return;
+      O(r);
+    } else r.pointerType !== "keyboard" && h && m(r);
+  }) : (x.onPressStart = (r) => {
+    A.current = r.pointerType, F.current = R, q.current = p, h && (r.pointerType === "mouse" && !p || r.pointerType === "keyboard" && (!S || Ke())) && m(r);
+  }, x.onPress = (r) => {
+    (r.pointerType === "touch" || r.pointerType === "pen" || r.pointerType === "virtual" || r.pointerType === "keyboard" && k && $e() || r.pointerType === "mouse" && q.current) && (k ? O(r) : h && m(r));
+  }), g["data-collection"] = it(t.collection), g["data-key"] = l, x.preventFocusOnPress = o, o && (x = Y(x, {
+    onPressStart(r) {
+      r.pointerType !== "touch" && (t.setFocused(!0), t.setFocusedKey(l));
+    },
+    onPress(r) {
+      r.pointerType === "touch" && (t.setFocused(!0), t.setFocusedKey(l));
+    }
+  })), B)
+    for (let r of [
+      "onPressStart",
+      "onPressEnd",
+      "onPressChange",
+      "onPress",
+      "onPressUp",
+      "onClick"
+    ]) B[r] && (x[r] = Oe(x[r], B[r]));
+  let { pressProps: G, isPressed: N } = ke(x), X = D ? (r) => {
+    A.current === "mouse" && (r.stopPropagation(), r.preventDefault(), O(r));
+  } : void 0, { longPressProps: _ } = _e({
+    isDisabled: !R,
+    onLongPress(r) {
+      r.pointerType === "touch" && (m(r), t.setSelectionBehavior("toggle"));
+    }
+  }), c = (r) => {
+    A.current === "touch" && F.current && r.preventDefault();
+  }, d = b !== "none" && t.isLink(l) ? (r) => {
+    ze.isOpening || r.preventDefault();
+  } : void 0;
+  return {
+    itemProps: Y(
+      g,
+      h || p || o && !a ? G : {},
+      R ? _ : {},
+      {
+        onDoubleClick: X,
+        onDragStartCapture: c,
+        onClick: d,
+        id: e
+      },
+      // Prevent DOM focus from moving on mouse down when using virtual focus
+      o ? {
+        onMouseDown: (r) => r.preventDefault()
+      } : void 0
+    ),
+    isPressed: N,
+    isSelected: t.isSelected(l),
+    isFocused: t.isFocused && t.focusedKey === l,
+    isDisabled: a,
+    allowsSelection: h,
+    hasAction: k
+  };
+}
+function $e() {
+  let n = window.event;
+  return n?.key === "Enter";
+}
+function Ke() {
+  let n = window.event;
+  return n?.key === " " || n?.code === "Space";
+}
+class Se {
+  getItemRect(e) {
+    let t = this.ref.current;
+    if (!t) return null;
+    let l = e != null ? J(this.ref, e) : null;
+    if (!l) return null;
+    let i = t.getBoundingClientRect(), s = l.getBoundingClientRect();
+    return {
+      x: s.left - i.left + t.scrollLeft,
+      y: s.top - i.top + t.scrollTop,
+      width: s.width,
+      height: s.height
+    };
+  }
+  getContentSize() {
+    let e = this.ref.current;
+    var t, l;
+    return {
+      width: (t = e?.scrollWidth) !== null && t !== void 0 ? t : 0,
+      height: (l = e?.scrollHeight) !== null && l !== void 0 ? l : 0
+    };
+  }
+  getVisibleRect() {
+    let e = this.ref.current;
+    var t, l, i, s;
+    return {
+      x: (t = e?.scrollLeft) !== null && t !== void 0 ? t : 0,
+      y: (l = e?.scrollTop) !== null && l !== void 0 ? l : 0,
+      width: (i = e?.offsetWidth) !== null && i !== void 0 ? i : 0,
+      height: (s = e?.offsetHeight) !== null && s !== void 0 ? s : 0
+    };
+  }
+  constructor(e) {
+    this.ref = e;
+  }
+}
+class Rt {
+  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 l = e;
+    for (; l != null; ) {
+      let i = this.collection.getItem(l);
+      if (i?.type === "item" && !this.isDisabled(i)) return l;
+      l = t(l);
+    }
+    return null;
+  }
+  getNextKey(e) {
+    let t = e;
+    return t = this.collection.getKeyAfter(t), this.findNextNonDisabled(t, (l) => this.collection.getKeyAfter(l));
+  }
+  getPreviousKey(e) {
+    let t = e;
+    return t = this.collection.getKeyBefore(t), this.findNextNonDisabled(t, (l) => this.collection.getKeyBefore(l));
+  }
+  findKey(e, t, l) {
+    let i = e, s = this.layoutDelegate.getItemRect(i);
+    if (!s || i == null) return null;
+    let o = s;
+    do {
+      if (i = t(i), i == null) break;
+      s = this.layoutDelegate.getItemRect(i);
+    } while (s && l(o, s) && i != null);
+    return i;
+  }
+  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, (l) => this.layoutDelegate[t](l))) : this.layout === "grid" ? this.orientation === "vertical" ? this.getNextColumn(e, this.direction === "rtl") : this.findKey(e, (l) => this.getNextColumn(l, 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, (l) => this.layoutDelegate[t](l))) : this.layout === "grid" ? this.orientation === "vertical" ? this.getNextColumn(e, this.direction === "ltr") : this.findKey(e, (l) => this.getNextColumn(l, 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, l = this.layoutDelegate.getItemRect(e);
+    if (!l) return null;
+    if (t && !ge(t)) return this.getFirstKey();
+    let i = e;
+    if (this.orientation === "horizontal") {
+      let s = Math.max(0, l.x + l.width - this.layoutDelegate.getVisibleRect().width);
+      for (; l && l.x > s && i != null; )
+        i = this.getKeyAbove(i), l = i == null ? null : this.layoutDelegate.getItemRect(i);
+    } else {
+      let s = Math.max(0, l.y + l.height - this.layoutDelegate.getVisibleRect().height);
+      for (; l && l.y > s && i != null; )
+        i = this.getKeyAbove(i), l = i == null ? null : this.layoutDelegate.getItemRect(i);
+    }
+    return i ?? this.getFirstKey();
+  }
+  getKeyPageBelow(e) {
+    let t = this.ref.current, l = this.layoutDelegate.getItemRect(e);
+    if (!l) return null;
+    if (t && !ge(t)) return this.getLastKey();
+    let i = e;
+    if (this.orientation === "horizontal") {
+      let s = Math.min(this.layoutDelegate.getContentSize().width, l.y - l.width + this.layoutDelegate.getVisibleRect().width);
+      for (; l && l.x < s && i != null; )
+        i = this.getKeyBelow(i), l = i == null ? null : this.layoutDelegate.getItemRect(i);
+    } else {
+      let s = Math.min(this.layoutDelegate.getContentSize().height, l.y - l.height + this.layoutDelegate.getVisibleRect().height);
+      for (; l && l.y < s && i != null; )
+        i = this.getKeyBelow(i), l = i == null ? null : this.layoutDelegate.getItemRect(i);
+    }
+    return i ?? this.getLastKey();
+  }
+  getKeyForSearch(e, t) {
+    if (!this.collator) return null;
+    let l = this.collection, i = t || this.getFirstKey();
+    for (; i != null; ) {
+      let s = l.getItem(i);
+      if (!s) return null;
+      let o = s.textValue.slice(0, e.length);
+      if (s.textValue && this.collator.compare(o, e) === 0) return i;
+      i = this.getNextKey(i);
+    }
+    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 Se(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 Se(this.ref);
+    this.layout === "stack" && this.orientation === "vertical" && (this.getKeyLeftOf = void 0, this.getKeyRightOf = void 0);
+  }
+}
+class ot {
+  build(e, t) {
+    return this.context = t, xe(() => this.iterateCollection(e));
+  }
+  *iterateCollection(e) {
+    let { children: t, items: l } = e;
+    if (L.isValidElement(t) && t.type === L.Fragment) yield* this.iterateCollection({
+      children: t.props.children,
+      items: l
+    });
+    else if (typeof t == "function") {
+      if (!l) throw new Error("props.children was a function but props.items is missing");
+      let i = 0;
+      for (let s of l)
+        yield* this.getFullNode({
+          value: s,
+          index: i
+        }, {
+          renderer: t
+        }), i++;
+    } else {
+      let i = [];
+      L.Children.forEach(t, (o) => {
+        o && i.push(o);
+      });
+      let s = 0;
+      for (let o of i) {
+        let f = this.getFullNode({
+          element: o,
+          index: s
+        }, {});
+        for (let a of f)
+          s++, yield a;
+      }
+    }
+  }
+  getKey(e, t, l, i) {
+    if (e.key != null) return e.key;
+    if (t.type === "cell" && t.key != null) return `${i}${t.key}`;
+    let s = t.value;
+    if (s != null) {
+      var o;
+      let f = (o = s.key) !== null && o !== void 0 ? o : s.id;
+      if (f == null) throw new Error("No key found for item");
+      return f;
+    }
+    return i ? `${i}.${t.index}` : `$.${t.index}`;
+  }
+  getChildState(e, t) {
+    return {
+      renderer: t.renderer || e.renderer
+    };
+  }
+  *getFullNode(e, t, l, i) {
+    if (L.isValidElement(e.element) && e.element.type === L.Fragment) {
+      let y = [];
+      L.Children.forEach(e.element.props.children, (S) => {
+        y.push(S);
+      });
+      var s;
+      let h = (s = e.index) !== null && s !== void 0 ? s : 0;
+      for (const S of y) yield* this.getFullNode({
+        element: S,
+        index: h++
+      }, t, l, i);
+      return;
+    }
+    let o = e.element;
+    if (!o && e.value && t && t.renderer) {
+      let y = this.cache.get(e.value);
+      if (y && (!y.shouldInvalidate || !y.shouldInvalidate(this.context))) {
+        y.index = e.index, y.parentKey = i ? i.key : null, yield y;
+        return;
+      }
+      o = t.renderer(e.value);
+    }
+    if (L.isValidElement(o)) {
+      let y = o.type;
+      if (typeof y != "function" && typeof y.getCollectionNode != "function") {
+        let D = o.type;
+        throw new Error(`Unknown element <${D}> in collection.`);
+      }
+      let h = y.getCollectionNode(o.props, this.context);
+      var f;
+      let S = (f = e.index) !== null && f !== void 0 ? f : 0, p = h.next();
+      for (; !p.done && p.value; ) {
+        let D = p.value;
+        e.index = S;
+        var a;
+        let k = (a = D.key) !== null && a !== void 0 ? a : null;
+        k == null && (k = D.element ? null : this.getKey(o, e, t, l));
+        let R = [
+          ...this.getFullNode({
+            ...D,
+            key: k,
+            index: S,
+            wrapper: ct(e.wrapper, D.wrapper)
+          }, this.getChildState(t, D), l ? `${l}${o.key}` : o.key, i)
+        ];
+        for (let F of R) {
+          var $, I;
+          F.value = (I = ($ = D.value) !== null && $ !== void 0 ? $ : e.value) !== null && I !== void 0 ? I : null, F.value && this.cache.set(F.value, F);
+          var b;
+          if (e.type && F.type !== e.type) throw new Error(`Unsupported type <${ce(F.type)}> in <${ce((b = i?.type) !== null && b !== void 0 ? b : "unknown parent type")}>. Only <${ce(e.type)}> is supported.`);
+          S++, yield F;
+        }
+        p = h.next(R);
+      }
+      return;
+    }
+    if (e.key == null || e.type == null) return;
+    let v = this;
+    var m, g;
+    let E = {
+      type: e.type,
+      props: e.props,
+      key: e.key,
+      parentKey: i ? i.key : null,
+      value: (m = e.value) !== null && m !== void 0 ? m : null,
+      level: i ? i.level + 1 : 0,
+      index: e.index,
+      rendered: e.rendered,
+      textValue: (g = e.textValue) !== null && g !== void 0 ? g : "",
+      "aria-label": e["aria-label"],
+      wrapper: e.wrapper,
+      shouldInvalidate: e.shouldInvalidate,
+      hasChildNodes: e.hasChildNodes || !1,
+      childNodes: xe(function* () {
+        if (!e.hasChildNodes || !e.childNodes) return;
+        let y = 0;
+        for (let h of e.childNodes()) {
+          h.key != null && (h.key = `${E.key}${h.key}`);
+          let S = v.getFullNode({
+            ...h,
+            index: y
+          }, v.getChildState(t, h), E.key, E);
+          for (let p of S)
+            y++, yield p;
+        }
+      })
+    };
+    yield E;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+function xe(n) {
+  let e = [], t = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let l of e) yield l;
+      t || (t = n());
+      for (let l of t)
+        e.push(l), yield l;
+    }
+  };
+}
+function ct(n, e) {
+  if (n && e) return (t) => n(e(t));
+  if (n) return n;
+  if (e) return e;
+}
+function ce(n) {
+  return n[0].toUpperCase() + n.slice(1);
+}
+function Bt(n, e, t) {
+  let l = W(() => new ot(), []), { children: i, items: s, collection: o } = n;
+  return W(() => {
+    if (o) return o;
+    let a = l.build({
+      children: i,
+      items: s
+    }, t);
+    return e(a);
+  }, [
+    l,
+    i,
+    s,
+    o,
+    t,
+    e
+  ]);
+}
+function ut(n, e) {
+  return typeof e.getChildren == "function" ? e.getChildren(n.key) : n.childNodes;
+}
+function at(n) {
+  return ft(n, 0);
+}
+function ft(n, e) {
+  if (e < 0) return;
+  let t = 0;
+  for (let l of n) {
+    if (t === e) return l;
+    t++;
+  }
+}
+function Mt(n) {
+  let e;
+  for (let t of n) e = t;
+  return e;
+}
+function ue(n, e, t) {
+  if (e.parentKey === t.parentKey) return e.index - t.index;
+  let l = [
+    ...we(n, e),
+    e
+  ], i = [
+    ...we(n, t),
+    t
+  ], s = l.slice(0, i.length).findIndex((o, f) => o !== i[f]);
+  return s !== -1 ? (e = l[s], t = i[s], e.index - t.index) : l.findIndex((o) => o === t) >= 0 ? 1 : (i.findIndex((o) => o === e) >= 0, -1);
+}
+function we(n, e) {
+  let t = [], l = e;
+  for (; l?.parentKey != null; )
+    l = n.getItem(l.parentKey), l && t.unshift(l);
+  return t;
+}
+const Lt = /* @__PURE__ */ Q(null), Ot = /* @__PURE__ */ Q(null), zt = /* @__PURE__ */ Q(null), dt = {
+  CollectionRoot({ collection: n, renderDropIndicator: e }) {
+    return De(n, null, e);
+  },
+  CollectionBranch({ collection: n, parent: e, renderDropIndicator: t }) {
+    return De(n, e, t);
+  }
+};
+function De(n, e, t) {
+  return Xe({
+    items: e ? n.getChildren(e.key) : n,
+    dependencies: [
+      t
+    ],
+    children(l) {
+      let i = l.render(l);
+      return !t || l.type !== "item" ? i : /* @__PURE__ */ L.createElement(L.Fragment, null, t({
+        type: "item",
+        key: l.key,
+        dropPosition: "before"
+      }), i, ht(n, l, t));
+    }
+  });
+}
+function ht(n, e, t) {
+  let l = e.key, i = n.getKeyAfter(l), s = i != null ? n.getItem(i) : null;
+  for (; s != null && s.type !== "item"; )
+    i = n.getKeyAfter(s.key), s = i != null ? n.getItem(i) : null;
+  let o = e.nextKey != null ? n.getItem(e.nextKey) : null;
+  for (; o != null && o.type !== "item"; ) o = o.nextKey != null ? n.getItem(o.nextKey) : null;
+  let f = [];
+  if (o == null) {
+    let a = e;
+    for (; a && (!s || a.parentKey !== s.parentKey && s.level < a.level); ) {
+      let $ = t({
+        type: "item",
+        key: a.key,
+        dropPosition: "after"
+      });
+      /* @__PURE__ */ Me($) && f.push(/* @__PURE__ */ Le($, {
+        key: `${a.key}-after`
+      })), a = a.parentKey != null ? n.getItem(a.parentKey) : null;
+    }
+  }
+  return f;
+}
+const Vt = /* @__PURE__ */ Q(dt);
+function Ut(n) {
+  return W(() => n != null ? /* @__PURE__ */ new Set([
+    n
+  ]) : null, [
+    n
+  ]);
+}
+class C extends Set {
+  constructor(e, t, l) {
+    super(e), e instanceof C ? (this.anchorKey = t ?? e.anchorKey, this.currentKey = l ?? e.currentKey) : (this.anchorKey = t ?? null, this.currentKey = l ?? null);
+  }
+}
+function yt(n, e) {
+  if (n.size !== e.size) return !1;
+  for (let t of n)
+    if (!e.has(t)) return !1;
+  return !0;
+}
+function Ht(n) {
+  let { selectionMode: e = "none", disallowEmptySelection: t = !1, allowDuplicateSelectionEvents: l, selectionBehavior: i = "toggle", disabledBehavior: s = "all" } = n, o = w(!1), [, f] = oe(!1), a = w(null), $ = w(null), [, I] = oe(null), b = W(() => Fe(n.selectedKeys), [
+    n.selectedKeys
+  ]), v = W(() => Fe(n.defaultSelectedKeys, new C()), [
+    n.defaultSelectedKeys
+  ]), [m, g] = Ze(b, v, n.onSelectionChange), E = W(() => n.disabledKeys ? new Set(n.disabledKeys) : /* @__PURE__ */ new Set(), [
+    n.disabledKeys
+  ]), [y, h] = oe(i);
+  i === "replace" && y === "toggle" && typeof m == "object" && m.size === 0 && h("replace");
+  let S = w(i);
+  return j(() => {
+    i !== S.current && (h(i), S.current = i);
+  }, [
+    i
+  ]), {
+    selectionMode: e,
+    disallowEmptySelection: t,
+    selectionBehavior: y,
+    setSelectionBehavior: h,
+    get isFocused() {
+      return o.current;
+    },
+    setFocused(p) {
+      o.current = p, f(p);
+    },
+    get focusedKey() {
+      return a.current;
+    },
+    get childFocusStrategy() {
+      return $.current;
+    },
+    setFocusedKey(p, D = "first") {
+      a.current = p, $.current = D, I(p);
+    },
+    selectedKeys: m,
+    setSelectedKeys(p) {
+      (l || !yt(p, m)) && g(p);
+    },
+    disabledKeys: E,
+    disabledBehavior: s
+  };
+}
+function Fe(n, e) {
+  return n ? n === "all" ? "all" : new C(n) : e;
+}
+class Be {
+  /**
+  * 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((l) => t.has(l)), this._isSelectAll;
+  }
+  get firstSelectedKey() {
+    let e = null;
+    for (let l of this.state.selectedKeys) {
+      let i = this.collection.getItem(l);
+      (!e || i && ue(this.collection, i, e) < 0) && (e = i);
+    }
+    var t;
+    return (t = e?.key) !== null && t !== void 0 ? t : null;
+  }
+  get lastSelectedKey() {
+    let e = null;
+    for (let l of this.state.selectedKeys) {
+      let i = this.collection.getItem(l);
+      (!e || i && ue(this.collection, i, e) > 0) && (e = i);
+    }
+    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 l;
+    if (this.state.selectedKeys === "all") l = new C([
+      t
+    ], t, t);
+    else {
+      let o = this.state.selectedKeys;
+      var i;
+      let f = (i = o.anchorKey) !== null && i !== void 0 ? i : t;
+      l = new C(o, f, t);
+      var s;
+      for (let a of this.getKeyRange(f, (s = o.currentKey) !== null && s !== void 0 ? s : t)) l.delete(a);
+      for (let a of this.getKeyRange(t, f)) this.canSelectItem(a) && l.add(a);
+    }
+    this.state.setSelectedKeys(l);
+  }
+  getKeyRange(e, t) {
+    let l = this.collection.getItem(e), i = this.collection.getItem(t);
+    return l && i ? ue(this.collection, l, i) <= 0 ? this.getKeyRangeInternal(e, t) : this.getKeyRangeInternal(t, e) : [];
+  }
+  getKeyRangeInternal(e, t) {
+    var l;
+    if (!((l = this.layoutDelegate) === null || l === void 0) && l.getKeyRange) return this.layoutDelegate.getKeyRange(e, t);
+    let i = [], s = e;
+    for (; s != null; ) {
+      let o = this.collection.getItem(s);
+      if (o && (o.type === "item" || o.type === "cell" && this.allowsCellSelection) && i.push(s), s === t) return i;
+      s = this.collection.getKeyAfter(s);
+    }
+    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 l = new C(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+    l.has(t) ? l.delete(t) : this.canSelectItem(t) && (l.add(t), l.anchorKey = t, l.currentKey = t), !(this.disallowEmptySelection && l.size === 0) && this.state.setSelectedKeys(l);
+  }
+  /**
+  * 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 l = this.canSelectItem(t) ? new C([
+      t
+    ], t, t) : new C();
+    this.state.setSelectedKeys(l);
+  }
+  /**
+  * Replaces the selection with the given keys.
+  */
+  setSelectedKeys(e) {
+    if (this.selectionMode === "none") return;
+    let t = new C();
+    for (let l of e) {
+      let i = this.getKey(l);
+      if (i != null && (t.add(i), this.selectionMode === "single"))
+        break;
+    }
+    this.state.setSelectedKeys(t);
+  }
+  getSelectAllKeys() {
+    let e = [], t = (l) => {
+      for (; l != null; ) {
+        if (this.canSelectItem(l)) {
+          var i;
+          let o = this.collection.getItem(l);
+          o?.type === "item" && e.push(l);
+          var s;
+          o?.hasChildNodes && (this.allowsCellSelection || o.type !== "item") && t((s = (i = at(ut(o, this.collection))) === null || i === void 0 ? void 0 : i.key) !== null && s !== void 0 ? s : null);
+        }
+        l = this.collection.getKeyAfter(l);
+      }
+    };
+    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 C());
+  }
+  /**
+  * 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 l of e)
+      if (!t.has(l)) return !1;
+    for (let l of t)
+      if (!e.has(l)) return !1;
+    return !0;
+  }
+  canSelectItem(e) {
+    var t;
+    if (this.state.selectionMode === "none" || this.state.disabledKeys.has(e)) return !1;
+    let l = this.collection.getItem(e);
+    return !(!l || !(l == null || (t = l.props) === null || t === void 0) && t.isDisabled || l.type === "cell" && !this.allowsCellSelection);
+  }
+  isDisabled(e) {
+    var t, l;
+    return this.state.disabledBehavior === "all" && (this.state.disabledKeys.has(e) || !!(!((l = this.collection.getItem(e)) === null || l === void 0 || (t = l.props) === null || t === void 0) && t.isDisabled));
+  }
+  isLink(e) {
+    var t, l;
+    return !!(!((l = this.collection.getItem(e)) === null || l === void 0 || (t = l.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 Be(e, this.state, {
+      allowsCellSelection: this.allowsCellSelection,
+      layoutDelegate: this.layoutDelegate || void 0
+    });
+  }
+  constructor(e, t, l) {
+    this.collection = e, this.state = t;
+    var i;
+    this.allowsCellSelection = (i = l?.allowsCellSelection) !== null && i !== void 0 ? i : !1, this._isSelectAll = null, this.layoutDelegate = l?.layoutDelegate || null;
+  }
+}
+export {
+  Rt as $,
+  At as a,
+  ut as b,
+  Ct as c,
+  Ht as d,
+  Bt as e,
+  Be as f,
+  Vt as g,
+  Lt as h,
+  zt as i,
+  rt as j,
+  dt as k,
+  Ut as l,
+  Mt as m,
+  at as n,
+  ft as o,
+  Se as p,
+  Ot as q,
+  Ce as r,
+  Qe as s,
+  Ae as t,
+  Je as u,
+  et as v,
+  H as w,
+  tt as x,
+  _e as y
+};
+//# sourceMappingURL=SelectionManager-CtwcAiw4.es.js.map