@commercetools/nimbus 0.0.13-rc2 → 0.0.14-rc1

package/dist/chunks/Collection-CDJ_uFKV.es.js

@@ -0,0 +1,1925 @@
+import S, { useRef as E, useState as Y, useEffect as X, useMemo as B, cloneElement as qe, forwardRef as We, useContext as H, createContext as G, useCallback as Z, isValidElement as ot } from "react";
+import { c as Ge, b as st } from "./FocusScope-B5Aod9bV.es.js";
+import { d as me, a as _e, c as we, $ as le, f as ut } from "./mergeProps-CtwSzqnr.es.js";
+import { $ as De } from "./focusWithoutScrolling-CDw3JYiq.es.js";
+import { $ as je, d as at } from "./openLink-BwkmFekP.es.js";
+import { $ as ee } from "./useEvent-k0_MYJWL.es.js";
+import { a as ct, b as Ee, c as ke } from "./scrollIntoView-CdmKMaOn.es.js";
+import { b as Ie } from "./useFocusVisible-DGwGbqVH.es.js";
+import { $ as be } from "./focusSafely-D8bIeV7X.es.js";
+import { flushSync as dt, createPortal as ft } from "react-dom";
+import { $ as ht } from "./context-Pt-0ojuK.es.js";
+import { b as yt, f as pt } from "./platform-BOO1jCtB.es.js";
+import { $ as Ye } from "./usePress-CEcydhMs.es.js";
+import { j as vt, $ as gt, g as mt } from "./utils-4CfAFtL7.es.js";
+import { $ as bt } from "./useSyncRef-KqQTqZax.es.js";
+import { $ as St } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { b as Kt } from "./domHelpers-InH3T0qs.es.js";
+import { a as $t } from "./Hidden-j3Lbt7xL.es.js";
+import { b as Pe } from "./useFocusable-ZY85zm7p.es.js";
+import { $ as Xe } from "./SSRProvider-Cu8KibIK.es.js";
+import { $ as xt } from "./useControlledState-u436Wbp1.es.js";
+function Fe(r, 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, n) => !Object.is(l, i[n]))) && r(), i.current = e;
+  }, e);
+}
+const Ct = "react-aria-clear-focus", wt = "react-aria-focus";
+function q(r) {
+  return yt() ? r.metaKey : r.ctrlKey;
+}
+let Dt = 0;
+const he = /* @__PURE__ */ new Map();
+function Et(r) {
+  let [e, t] = Y();
+  return vt(() => {
+    if (!r) return;
+    let i = he.get(r);
+    if (i)
+      t(i.element.id);
+    else {
+      let l = `react-aria-description-${Dt++}`;
+      t(l);
+      let n = document.createElement("div");
+      n.id = l, n.style.display = "none", n.textContent = r, document.body.appendChild(n), i = {
+        refCount: 0,
+        element: n
+      }, he.set(r, i);
+    }
+    return i.refCount++, () => {
+      i && --i.refCount === 0 && (i.element.remove(), he.delete(r));
+    };
+  }, [
+    r
+  ]), {
+    "aria-describedby": r ? e : void 0
+  };
+}
+const kt = 500;
+function It(r) {
+  let { isDisabled: e, onLongPressStart: t, onLongPressEnd: i, onLongPress: l, threshold: n = kt, accessibilityDescription: o } = r;
+  const c = E(void 0);
+  let { addGlobalListener: u, removeGlobalListener: v } = St(), { pressProps: $ } = Ye({
+    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
+        })), gt(f.target).activeElement !== f.target && mt(f.target), l && l({
+          ...f,
+          type: "longpress"
+        }), c.current = void 0;
+      }, n), f.pointerType === "touch")) {
+        let h = (p) => {
+          p.preventDefault();
+        };
+        u(f.target, "contextmenu", h, {
+          once: !0
+        }), u(window, "pointerup", () => {
+          setTimeout(() => {
+            v(f.target, "contextmenu", h);
+          }, 30);
+        }, {
+          once: !0
+        });
+      }
+    },
+    onPressEnd(f) {
+      c.current && clearTimeout(c.current), i && (f.pointerType === "mouse" || f.pointerType === "touch") && i({
+        ...f,
+        type: "longpressend"
+      });
+    }
+  }), d = Et(l && !e ? o : void 0);
+  return {
+    longPressProps: bt($, d)
+  };
+}
+function Ze(r) {
+  let e = Ft(Kt(r));
+  e !== r && (e && Pt(e, r), r && Je(r, e));
+}
+function Pt(r, e) {
+  r.dispatchEvent(new FocusEvent("blur", {
+    relatedTarget: e
+  })), r.dispatchEvent(new FocusEvent("focusout", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function Je(r, e) {
+  r.dispatchEvent(new FocusEvent("focus", {
+    relatedTarget: e
+  })), r.dispatchEvent(new FocusEvent("focusin", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function Ft(r) {
+  let e = Ge(r), t = e?.getAttribute("aria-activedescendant");
+  return t && r.getElementById(t) || e;
+}
+function Se(r) {
+  return pt() ? r.altKey : r.ctrlKey;
+}
+function ie(r, e) {
+  var t, i;
+  let l = `[data-key="${CSS.escape(String(e))}"]`, n = (t = r.current) === null || t === void 0 ? void 0 : t.dataset.collection;
+  return n && (l = `[data-collection="${CSS.escape(n)}"]${l}`), (i = r.current) === null || i === void 0 ? void 0 : i.querySelector(l);
+}
+const Qe = /* @__PURE__ */ new WeakMap();
+function Mt(r) {
+  let e = _e();
+  return Qe.set(r, e), e;
+}
+function At(r) {
+  return Qe.get(r);
+}
+const Rt = 1e3;
+function Tt(r) {
+  let { keyboardDelegate: e, selectionManager: t, onTypeSelect: i } = r, l = E({
+    search: "",
+    timeout: void 0
+  }).current, n = (o) => {
+    let c = Ot(o.key);
+    if (!(!c || o.ctrlKey || o.metaKey || !o.currentTarget.contains(o.target) || l.search.length === 0 && c === " ")) {
+      if (c === " " && l.search.trim().length > 0 && (o.preventDefault(), "continuePropagation" in o || o.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 = "";
+      }, Rt);
+    }
+  };
+  return {
+    typeSelectProps: {
+      // Using a capturing listener to catch the keydown event before
+      // other hooks in order to handle the Spacebar event.
+      onKeyDownCapture: e.getKeyForSearch ? n : void 0
+    }
+  };
+}
+function Ot(r) {
+  return r.length === 1 || !/^[A-Z]/i.test(r) ? r : "";
+}
+function $i(r) {
+  let { selectionManager: e, keyboardDelegate: t, ref: i, autoFocus: l = !1, shouldFocusWrap: n = !1, disallowEmptySelection: o = !1, disallowSelectAll: c = !1, escapeKeyBehavior: u = "clearSelection", selectOnFocus: v = e.selectionBehavior === "replace", disallowTypeAhead: $ = !1, shouldUseVirtualFocus: d, allowsTabNavigation: f = !1, isVirtualized: h, scrollRef: p = i, linkBehavior: K = "action" } = r, { direction: g } = ht(), m = je(), C = (a) => {
+    var b;
+    if (a.altKey && a.key === "Tab" && a.preventDefault(), !(!((b = i.current) === null || b === void 0) && b.contains(a.target))) return;
+    const s = (y, z) => {
+      if (y != null) {
+        if (e.isLink(y) && K === "selection" && v && !Se(a)) {
+          dt(() => {
+            e.setFocusedKey(y, z);
+          });
+          let U = ie(i, y), Ce = e.getItemProps(y);
+          U && m.open(U, a, Ce.href, Ce.routerOptions);
+          return;
+        }
+        if (e.setFocusedKey(y, z), e.isLink(y) && K === "override") return;
+        a.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(y) : v && !Se(a) && e.replaceSelection(y);
+      }
+    };
+    switch (a.key) {
+      case "ArrowDown":
+        if (t.getKeyBelow) {
+          var w, F, P;
+          let y = e.focusedKey != null ? (w = t.getKeyBelow) === null || w === void 0 ? void 0 : w.call(t, e.focusedKey) : (F = t.getFirstKey) === null || F === void 0 ? void 0 : F.call(t);
+          y == null && n && (y = (P = t.getFirstKey) === null || P === void 0 ? void 0 : P.call(t, e.focusedKey)), y != null && (a.preventDefault(), s(y));
+        }
+        break;
+      case "ArrowUp":
+        if (t.getKeyAbove) {
+          var L, N, oe;
+          let y = 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);
+          y == null && n && (y = (oe = t.getLastKey) === null || oe === void 0 ? void 0 : oe.call(t, e.focusedKey)), y != null && (a.preventDefault(), s(y));
+        }
+        break;
+      case "ArrowLeft":
+        if (t.getKeyLeftOf) {
+          var se, ue, ae;
+          let y = e.focusedKey != null ? (se = t.getKeyLeftOf) === null || se === void 0 ? void 0 : se.call(t, e.focusedKey) : null;
+          y == null && n && (y = g === "rtl" ? (ue = t.getFirstKey) === null || ue === void 0 ? void 0 : ue.call(t, e.focusedKey) : (ae = t.getLastKey) === null || ae === void 0 ? void 0 : ae.call(t, e.focusedKey)), y != null && (a.preventDefault(), s(y, g === "rtl" ? "first" : "last"));
+        }
+        break;
+      case "ArrowRight":
+        if (t.getKeyRightOf) {
+          var ce, de, fe;
+          let y = e.focusedKey != null ? (ce = t.getKeyRightOf) === null || ce === void 0 ? void 0 : ce.call(t, e.focusedKey) : null;
+          y == null && n && (y = g === "rtl" ? (de = t.getLastKey) === null || de === void 0 ? void 0 : de.call(t, e.focusedKey) : (fe = t.getFirstKey) === null || fe === void 0 ? void 0 : fe.call(t, e.focusedKey)), y != null && (a.preventDefault(), s(y, g === "rtl" ? "last" : "first"));
+        }
+        break;
+      case "Home":
+        if (t.getFirstKey) {
+          if (e.focusedKey === null && a.shiftKey) return;
+          a.preventDefault();
+          let y = t.getFirstKey(e.focusedKey, q(a));
+          e.setFocusedKey(y), y != null && (q(a) && a.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(y) : v && e.replaceSelection(y));
+        }
+        break;
+      case "End":
+        if (t.getLastKey) {
+          if (e.focusedKey === null && a.shiftKey) return;
+          a.preventDefault();
+          let y = t.getLastKey(e.focusedKey, q(a));
+          e.setFocusedKey(y), y != null && (q(a) && a.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(y) : v && e.replaceSelection(y));
+        }
+        break;
+      case "PageDown":
+        if (t.getKeyPageBelow && e.focusedKey != null) {
+          let y = t.getKeyPageBelow(e.focusedKey);
+          y != null && (a.preventDefault(), s(y));
+        }
+        break;
+      case "PageUp":
+        if (t.getKeyPageAbove && e.focusedKey != null) {
+          let y = t.getKeyPageAbove(e.focusedKey);
+          y != null && (a.preventDefault(), s(y));
+        }
+        break;
+      case "a":
+        q(a) && e.selectionMode === "multiple" && c !== !0 && (a.preventDefault(), e.selectAll());
+        break;
+      case "Escape":
+        u === "clearSelection" && !o && e.selectedKeys.size !== 0 && (a.stopPropagation(), a.preventDefault(), e.clearSelection());
+        break;
+      case "Tab":
+        if (!f) {
+          if (a.shiftKey) i.current.focus();
+          else {
+            let y = st(i.current, {
+              tabbable: !0
+            }), z, U;
+            do
+              U = y.lastChild(), U && (z = U);
+            while (U);
+            z && !z.contains(document.activeElement) && De(z);
+          }
+          break;
+        }
+    }
+  }, x = E({
+    top: 0,
+    left: 0
+  });
+  ee(p, "scroll", h ? void 0 : () => {
+    var a, b, s, w;
+    x.current = {
+      top: (s = (a = p.current) === null || a === void 0 ? void 0 : a.scrollTop) !== null && s !== void 0 ? s : 0,
+      left: (w = (b = p.current) === null || b === void 0 ? void 0 : b.scrollLeft) !== null && w !== void 0 ? w : 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 b, s;
+        let P = (N) => {
+          N != null && (e.setFocusedKey(N), v && !e.isSelected(N) && e.replaceSelection(N));
+        }, L = a.relatedTarget;
+        var w, F;
+        L && a.currentTarget.compareDocumentPosition(L) & Node.DOCUMENT_POSITION_FOLLOWING ? P((w = e.lastSelectedKey) !== null && w !== void 0 ? w : (b = t.getLastKey) === null || b === void 0 ? void 0 : b.call(t)) : P((F = e.firstSelectedKey) !== null && F !== void 0 ? F : (s = t.getFirstKey) === null || s === void 0 ? void 0 : s.call(t));
+      } else !h && p.current && (p.current.scrollTop = x.current.top, p.current.scrollLeft = x.current.left);
+      if (e.focusedKey != null && p.current) {
+        let P = ie(i, e.focusedKey);
+        P instanceof HTMLElement && (!P.contains(document.activeElement) && !d && De(P), Ie() === "keyboard" && Ee(P, {
+          containingElement: i.current
+        }));
+      }
+    }
+  }, M = (a) => {
+    a.currentTarget.contains(a.relatedTarget) || e.setFocused(!1);
+  }, A = E(!1);
+  ee(i, wt, d ? (a) => {
+    let { detail: b } = a;
+    a.stopPropagation(), e.setFocused(!0), b?.focusStrategy === "first" && (A.current = !0);
+  } : void 0);
+  let T = we(() => {
+    var a, b;
+    let s = (b = (a = t.getFirstKey) === null || a === void 0 ? void 0 : a.call(t)) !== null && b !== void 0 ? b : null;
+    if (s == null) {
+      let w = Ge();
+      Ze(i.current), Je(w, null), e.collection.size > 0 && (A.current = !1);
+    } else
+      e.setFocusedKey(s), A.current = !1;
+  });
+  Fe(() => {
+    A.current && T();
+  }, [
+    e.collection,
+    T
+  ]);
+  let I = we(() => {
+    e.collection.size > 0 && (A.current = !1);
+  });
+  Fe(() => {
+    I();
+  }, [
+    e.focusedKey,
+    I
+  ]), ee(i, Ct, d ? (a) => {
+    var b;
+    a.stopPropagation(), e.setFocused(!1), !((b = a.detail) === null || b === void 0) && b.clearFocusKey && e.setFocusedKey(null);
+  } : void 0);
+  const _ = E(l), O = E(!1);
+  X(() => {
+    if (_.current) {
+      var a, b;
+      let F = null;
+      var s;
+      l === "first" && (F = (s = (a = t.getFirstKey) === null || a === void 0 ? void 0 : a.call(t)) !== null && s !== void 0 ? s : null);
+      var w;
+      l === "last" && (F = (w = (b = t.getLastKey) === null || b === void 0 ? void 0 : b.call(t)) !== null && w !== void 0 ? w : 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 && be(i.current), e.collection.size > 0 && (_.current = !1, O.current = !0);
+    }
+  });
+  let V = E(e.focusedKey), D = E(null);
+  X(() => {
+    if (e.isFocused && e.focusedKey != null && (e.focusedKey !== V.current || O.current) && p.current && i.current) {
+      let a = Ie(), b = ie(i, e.focusedKey);
+      if (!(b instanceof HTMLElement))
+        return;
+      (a === "keyboard" || O.current) && (D.current && cancelAnimationFrame(D.current), D.current = requestAnimationFrame(() => {
+        p.current && (ct(p.current, b), a !== "virtual" && Ee(b, {
+          containingElement: i.current
+        }));
+      }));
+    }
+    !d && e.isFocused && e.focusedKey == null && V.current != null && i.current && be(i.current), V.current = e.focusedKey, O.current = !1;
+  }), X(() => () => {
+    D.current && cancelAnimationFrame(D.current);
+  }, []), ee(i, "react-aria-focus-scope-restore", (a) => {
+    a.preventDefault(), e.setFocused(!0);
+  });
+  let j = {
+    onKeyDown: C,
+    onFocus: k,
+    onBlur: M,
+    onMouseDown(a) {
+      p.current === a.target && a.preventDefault();
+    }
+  }, { typeSelectProps: ne } = Tt({
+    keyboardDelegate: t,
+    selectionManager: e
+  });
+  $ || (j = le(ne, j));
+  let Q;
+  d || (Q = e.focusedKey == null ? 0 : -1);
+  let re = Mt(e.collection);
+  return {
+    collectionProps: le(j, {
+      tabIndex: Q,
+      "data-collection": re
+    })
+  };
+}
+function xi(r) {
+  let { id: e, selectionManager: t, key: i, ref: l, shouldSelectOnPressUp: n, shouldUseVirtualFocus: o, focus: c, isDisabled: u, onAction: v, allowsDifferentPressOrigin: $, linkBehavior: d = "action" } = r, f = je();
+  e = _e(e);
+  let h = (s) => {
+    if (s.pointerType === "keyboard" && Se(s)) t.toggleSelection(i);
+    else {
+      if (t.selectionMode === "none") return;
+      if (t.isLink(i)) {
+        if (d === "selection" && l.current) {
+          let w = t.getItemProps(i);
+          f.open(l.current, s, w.href, w.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) : s && s.shiftKey ? t.extendSelection(i) : t.selectionBehavior === "toggle" || s && (q(s) || s.pointerType === "touch" || s.pointerType === "virtual") ? t.toggleSelection(i) : t.replaceSelection(i);
+    }
+  };
+  X(() => {
+    i === t.focusedKey && t.isFocused && (o ? Ze(l.current) : c ? c() : document.activeElement !== l.current && l.current && be(l.current));
+  }, [
+    l,
+    i,
+    t.focusedKey,
+    t.childFocusStrategy,
+    t.isFocused,
+    o
+  ]), u = u || t.isDisabled(i);
+  let p = {};
+  !o && !u ? p = {
+    tabIndex: i === t.focusedKey ? 0 : -1,
+    onFocus(s) {
+      s.target === l.current && t.setFocusedKey(i);
+    }
+  } : u && (p.onMouseDown = (s) => {
+    s.preventDefault();
+  });
+  let K = t.isLink(i) && d === "override", g = t.isLink(i) && d !== "selection" && d !== "none", m = !u && t.canSelectItem(i) && !K, C = (v || g) && !u, x = C && (t.selectionBehavior === "replace" ? !m : !m || t.isEmpty), k = C && m && t.selectionBehavior === "replace", M = x || k, A = E(null), T = M && m, I = E(!1), _ = E(!1), O = t.getItemProps(i), V = (s) => {
+    v && v(), g && l.current && f.open(l.current, s, O.href, O.routerOptions);
+  }, D = {
+    ref: l
+  };
+  if (n ? (D.onPressStart = (s) => {
+    A.current = s.pointerType, I.current = T, s.pointerType === "keyboard" && (!M || Ae()) && h(s);
+  }, $ ? (D.onPressUp = x ? void 0 : (s) => {
+    s.pointerType === "mouse" && m && h(s);
+  }, D.onPress = x ? V : (s) => {
+    s.pointerType !== "keyboard" && s.pointerType !== "mouse" && m && h(s);
+  }) : D.onPress = (s) => {
+    if (x || k && s.pointerType !== "mouse") {
+      if (s.pointerType === "keyboard" && !Me()) return;
+      V(s);
+    } else s.pointerType !== "keyboard" && m && h(s);
+  }) : (D.onPressStart = (s) => {
+    A.current = s.pointerType, I.current = T, _.current = x, m && (s.pointerType === "mouse" && !x || s.pointerType === "keyboard" && (!C || Ae())) && h(s);
+  }, D.onPress = (s) => {
+    (s.pointerType === "touch" || s.pointerType === "pen" || s.pointerType === "virtual" || s.pointerType === "keyboard" && M && Me() || s.pointerType === "mouse" && _.current) && (M ? V(s) : m && h(s));
+  }), p["data-collection"] = At(t.collection), p["data-key"] = i, D.preventFocusOnPress = o, o && (D = le(D, {
+    onPressStart(s) {
+      s.pointerType !== "touch" && (t.setFocused(!0), t.setFocusedKey(i));
+    },
+    onPress(s) {
+      s.pointerType === "touch" && (t.setFocused(!0), t.setFocusedKey(i));
+    }
+  })), O)
+    for (let s of [
+      "onPressStart",
+      "onPressEnd",
+      "onPressChange",
+      "onPress",
+      "onPressUp",
+      "onClick"
+    ]) O[s] && (D[s] = ut(D[s], O[s]));
+  let { pressProps: j, isPressed: ne } = Ye(D), Q = k ? (s) => {
+    A.current === "mouse" && (s.stopPropagation(), s.preventDefault(), V(s));
+  } : void 0, { longPressProps: re } = It({
+    isDisabled: !T,
+    onLongPress(s) {
+      s.pointerType === "touch" && (h(s), t.setSelectionBehavior("toggle"));
+    }
+  }), a = (s) => {
+    A.current === "touch" && I.current && s.preventDefault();
+  }, b = d !== "none" && t.isLink(i) ? (s) => {
+    at.isOpening || s.preventDefault();
+  } : void 0;
+  return {
+    itemProps: le(
+      p,
+      m || x || o && !u ? j : {},
+      T ? re : {},
+      {
+        onDoubleClick: Q,
+        onDragStartCapture: a,
+        onClick: b,
+        id: e
+      },
+      // Prevent DOM focus from moving on mouse down when using virtual focus
+      o ? {
+        onMouseDown: (s) => s.preventDefault()
+      } : void 0
+    ),
+    isPressed: ne,
+    isSelected: t.isSelected(i),
+    isFocused: t.isFocused && t.focusedKey === i,
+    isDisabled: u,
+    allowsSelection: m,
+    hasAction: M
+  };
+}
+function Me() {
+  let r = window.event;
+  return r?.key === "Enter";
+}
+function Ae() {
+  let r = window.event;
+  return r?.key === " " || r?.code === "Space";
+}
+class Re {
+  getItemRect(e) {
+    let t = this.ref.current;
+    if (!t) return null;
+    let i = e != null ? ie(this.ref, e) : null;
+    if (!i) return null;
+    let l = t.getBoundingClientRect(), n = i.getBoundingClientRect();
+    return {
+      x: n.left - l.left + t.scrollLeft,
+      y: n.top - l.top + t.scrollTop,
+      width: n.width,
+      height: n.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, n;
+    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: (n = e?.offsetHeight) !== null && n !== void 0 ? n : 0
+    };
+  }
+  constructor(e) {
+    this.ref = e;
+  }
+}
+class Ci {
+  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, n = this.layoutDelegate.getItemRect(l);
+    if (!n || l == null) return null;
+    let o = n;
+    do {
+      if (l = t(l), l == null) break;
+      n = this.layoutDelegate.getItemRect(l);
+    } while (n && i(o, n) && 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 && !ke(t)) return this.getFirstKey();
+    let l = e;
+    if (this.orientation === "horizontal") {
+      let n = Math.max(0, i.x + i.width - this.layoutDelegate.getVisibleRect().width);
+      for (; i && i.x > n && l != null; )
+        l = this.getKeyAbove(l), i = l == null ? null : this.layoutDelegate.getItemRect(l);
+    } else {
+      let n = Math.max(0, i.y + i.height - this.layoutDelegate.getVisibleRect().height);
+      for (; i && i.y > n && 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 && !ke(t)) return this.getLastKey();
+    let l = e;
+    if (this.orientation === "horizontal") {
+      let n = Math.min(this.layoutDelegate.getContentSize().width, i.y - i.width + this.layoutDelegate.getVisibleRect().width);
+      for (; i && i.x < n && l != null; )
+        l = this.getKeyBelow(l), i = l == null ? null : this.layoutDelegate.getItemRect(l);
+    } else {
+      let n = Math.min(this.layoutDelegate.getContentSize().height, i.y - i.height + this.layoutDelegate.getVisibleRect().height);
+      for (; i && i.y < n && 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 n = i.getItem(l);
+      if (!n) return null;
+      let o = n.textValue.slice(0, e.length);
+      if (n.textValue && this.collator.compare(o, 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 Re(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 Re(this.ref);
+    this.layout === "stack" && this.orientation === "vertical" && (this.getKeyLeftOf = void 0, this.getKeyRightOf = void 0);
+  }
+}
+class Lt {
+  build(e, t) {
+    return this.context = t, Te(() => this.iterateCollection(e));
+  }
+  *iterateCollection(e) {
+    let { children: t, items: i } = e;
+    if (S.isValidElement(t) && t.type === S.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 n of i)
+        yield* this.getFullNode({
+          value: n,
+          index: l
+        }, {
+          renderer: t
+        }), l++;
+    } else {
+      let l = [];
+      S.Children.forEach(t, (o) => {
+        o && l.push(o);
+      });
+      let n = 0;
+      for (let o of l) {
+        let c = this.getFullNode({
+          element: o,
+          index: n
+        }, {});
+        for (let u of c)
+          n++, 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 n = t.value;
+    if (n != null) {
+      var o;
+      let c = (o = n.key) !== null && o !== void 0 ? o : n.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 (S.isValidElement(e.element) && e.element.type === S.Fragment) {
+      let g = [];
+      S.Children.forEach(e.element.props.children, (C) => {
+        g.push(C);
+      });
+      var n;
+      let m = (n = e.index) !== null && n !== void 0 ? n : 0;
+      for (const C of g) yield* this.getFullNode({
+        element: C,
+        index: m++
+      }, t, i, l);
+      return;
+    }
+    let o = e.element;
+    if (!o && 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;
+      }
+      o = t.renderer(e.value);
+    }
+    if (S.isValidElement(o)) {
+      let g = o.type;
+      if (typeof g != "function" && typeof g.getCollectionNode != "function") {
+        let k = o.type;
+        throw new Error(`Unknown element <${k}> in collection.`);
+      }
+      let m = g.getCollectionNode(o.props, this.context);
+      var c;
+      let C = (c = e.index) !== null && c !== void 0 ? c : 0, x = m.next();
+      for (; !x.done && x.value; ) {
+        let k = x.value;
+        e.index = C;
+        var u;
+        let M = (u = k.key) !== null && u !== void 0 ? u : null;
+        M == null && (M = k.element ? null : this.getKey(o, e, t, i));
+        let T = [
+          ...this.getFullNode({
+            ...k,
+            key: M,
+            index: C,
+            wrapper: Bt(e.wrapper, k.wrapper)
+          }, this.getChildState(t, k), i ? `${i}${o.key}` : o.key, l)
+        ];
+        for (let I of T) {
+          var v, $;
+          I.value = ($ = (v = k.value) !== null && v !== void 0 ? v : e.value) !== null && $ !== void 0 ? $ : 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.`);
+          C++, yield I;
+        }
+        x = m.next(T);
+      }
+      return;
+    }
+    if (e.key == null || e.type == null) return;
+    let f = this;
+    var h, p;
+    let K = {
+      type: e.type,
+      props: e.props,
+      key: e.key,
+      parentKey: l ? l.key : null,
+      value: (h = e.value) !== null && h !== void 0 ? h : null,
+      level: l ? l.level + 1 : 0,
+      index: e.index,
+      rendered: e.rendered,
+      textValue: (p = e.textValue) !== null && p !== void 0 ? p : "",
+      "aria-label": e["aria-label"],
+      wrapper: e.wrapper,
+      shouldInvalidate: e.shouldInvalidate,
+      hasChildNodes: e.hasChildNodes || !1,
+      childNodes: Te(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 C = f.getFullNode({
+            ...m,
+            index: g
+          }, f.getChildState(t, m), K.key, K);
+          for (let x of C)
+            g++, yield x;
+        }
+      })
+    };
+    yield K;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+function Te(r) {
+  let e = [], t = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let i of e) yield i;
+      t || (t = r());
+      for (let i of t)
+        e.push(i), yield i;
+    }
+  };
+}
+function Bt(r, e) {
+  if (r && e) return (t) => r(e(t));
+  if (r) return r;
+  if (e) return e;
+}
+function ye(r) {
+  return r[0].toUpperCase() + r.slice(1);
+}
+function wi(r, e, t) {
+  let i = B(() => new Lt(), []), { children: l, items: n, collection: o } = r;
+  return B(() => {
+    if (o) return o;
+    let u = i.build({
+      children: l,
+      items: n
+    }, t);
+    return e(u);
+  }, [
+    i,
+    l,
+    n,
+    o,
+    t,
+    e
+  ]);
+}
+function Vt(r, e) {
+  return typeof e.getChildren == "function" ? e.getChildren(r.key) : r.childNodes;
+}
+function Nt(r) {
+  return zt(r, 0);
+}
+function zt(r, e) {
+  if (e < 0) return;
+  let t = 0;
+  for (let i of r) {
+    if (t === e) return i;
+    t++;
+  }
+}
+function Di(r) {
+  let e;
+  for (let t of r) e = t;
+  return e;
+}
+function pe(r, e, t) {
+  if (e.parentKey === t.parentKey) return e.index - t.index;
+  let i = [
+    ...Oe(r, e),
+    e
+  ], l = [
+    ...Oe(r, t),
+    t
+  ], n = i.slice(0, l.length).findIndex((o, c) => o !== l[c]);
+  return n !== -1 ? (e = i[n], t = l[n], e.index - t.index) : i.findIndex((o) => o === t) >= 0 ? 1 : (l.findIndex((o) => o === e) >= 0, -1);
+}
+function Oe(r, e) {
+  let t = [], i = e;
+  for (; i?.parentKey != null; )
+    i = r.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 Le;
+function Ut() {
+  if (Le) return ve;
+  Le = 1;
+  var r = S;
+  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 = r.useState, l = r.useEffect, n = r.useLayoutEffect, o = r.useDebugValue;
+  function c(d, f) {
+    var h = f(), p = i({ inst: { value: h, getSnapshot: f } }), K = p[0].inst, g = p[1];
+    return n(
+      function() {
+        K.value = h, K.getSnapshot = f, u(K) && g({ inst: K });
+      },
+      [d, h, f]
+    ), l(
+      function() {
+        return u(K) && g({ inst: K }), d(function() {
+          u(K) && g({ inst: K });
+        });
+      },
+      [d]
+    ), o(h), h;
+  }
+  function u(d) {
+    var f = d.getSnapshot;
+    d = d.value;
+    try {
+      var h = f();
+      return !t(d, h);
+    } catch {
+      return !0;
+    }
+  }
+  function v(d, f) {
+    return f();
+  }
+  var $ = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? v : c;
+  return ve.useSyncExternalStore = r.useSyncExternalStore !== void 0 ? r.useSyncExternalStore : $, 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 Be;
+function Ht() {
+  return Be || (Be = 1, process.env.NODE_ENV !== "production" && function() {
+    function r(h, p) {
+      return h === p && (h !== 0 || 1 / h === 1 / p) || h !== h && p !== p;
+    }
+    function e(h, p) {
+      $ || l.startTransition === void 0 || ($ = !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 = p();
+      if (!d) {
+        var g = p();
+        n(K, g) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), d = !0);
+      }
+      g = o({
+        inst: { value: K, getSnapshot: p }
+      });
+      var m = g[0].inst, C = g[1];
+      return u(
+        function() {
+          m.value = K, m.getSnapshot = p, t(m) && C({ inst: m });
+        },
+        [h, K, p]
+      ), c(
+        function() {
+          return t(m) && C({ inst: m }), h(function() {
+            t(m) && C({ inst: m });
+          });
+        },
+        [h]
+      ), v(K), K;
+    }
+    function t(h) {
+      var p = h.getSnapshot;
+      h = h.value;
+      try {
+        var K = p();
+        return !n(h, K);
+      } catch {
+        return !0;
+      }
+    }
+    function i(h, p) {
+      return p();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var l = S, n = typeof Object.is == "function" ? Object.is : r, o = l.useState, c = l.useEffect, u = l.useLayoutEffect, v = l.useDebugValue, $ = !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 Ve;
+function qt() {
+  return Ve || (Ve = 1, process.env.NODE_ENV === "production" ? te.exports = Ut() : te.exports = Ht()), te.exports;
+}
+var Wt = /* @__PURE__ */ qt();
+class $e {
+  get childNodes() {
+    throw new Error("childNodes is not supported");
+  }
+  clone() {
+    let e = new $e(this.type, 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;
+  }
+  constructor(e, t) {
+    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 = e, this.key = t;
+  }
+}
+class xe {
+  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);
+  }
+  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;
+  }
+  // TODO: this is pretty specific to menu, will need to check if it is generic enough
+  // Will need to handle varying levels I assume but will revisit after I get searchable menu working for base menu
+  // TODO: an alternative is to simply walk the collection and add all item nodes that match the filter and any sections/separators we encounter
+  // to an array, then walk that new array and fix all the next/Prev keys while adding them to the new collection
+  UNSTABLE_filter(e) {
+    let t = new xe(), i = null;
+    for (let l of this)
+      if (l.type === "section" && l.hasChildNodes) {
+        let n = l.clone(), o = null;
+        for (let c of this.getChildren(l.key)) if (Ne(c, e, this, t)) {
+          let u = c.clone();
+          o == null && (n.firstChildKey = u.key), t.firstKey == null && (t.firstKey = n.key), o && o.parentKey === u.parentKey ? (o.nextKey = u.key, u.prevKey = o.key) : u.prevKey = null, u.nextKey = null, t.addNode(u), o = u;
+        }
+        o && (o.type !== "header" ? (n.lastChildKey = o.key, i == null ? n.prevKey = null : (i.type === "section" || i.type === "separator") && (i.nextKey = n.key, n.prevKey = i.key), n.nextKey = null, i = n, t.addNode(n)) : (t.firstKey === n.key && (t.firstKey = null), t.removeNode(o.key)));
+      } else if (l.type === "separator") {
+        let n = l.clone();
+        n.nextKey = null, i?.type === "section" && (i.nextKey = n.key, n.prevKey = i.key, i = n, t.addNode(n));
+      } else {
+        let n = l.clone();
+        Ne(n, e, this, t) && (t.firstKey == null && (t.firstKey = n.key), i != null && i.type !== "section" && i.type !== "separator" && i.parentKey === n.parentKey ? (i.nextKey = n.key, n.prevKey = i.key) : n.prevKey = null, n.nextKey = null, t.addNode(n), i = n);
+      }
+    if (i?.type === "separator" && i.nextKey === null) {
+      let l;
+      i.prevKey != null && (l = t.getItem(i.prevKey), l.nextKey = null), t.removeNode(i.key), i = l;
+    }
+    return t.lastKey = i?.key || null, t;
+  }
+  constructor() {
+    this.keyMap = /* @__PURE__ */ new Map(), this.firstKey = null, this.lastKey = null, this.frozen = !1, this.itemCount = 0;
+  }
+}
+function Ne(r, e, t, i) {
+  if (r.type === "subdialogtrigger" || r.type === "submenutrigger") {
+    let l = [
+      ...t.getChildren(r.key)
+    ][0];
+    if (l && e(l.textValue)) {
+      let n = l.clone();
+      return i.addNode(n), !0;
+    } else return !1;
+  } else return r.type === "header" ? !0 : e(r.textValue);
+}
+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 W extends et {
+  get index() {
+    return this._index;
+  }
+  set index(e) {
+    this._index = e, this.ownerDocument.markDirty(this);
+  }
+  get level() {
+    return this.parentNode instanceof W ? this.parentNode.level + (this.node.type === "item" ? 1 : 0) : 0;
+  }
+  /**
+  * 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, n = this.getMutableNode();
+    n.index = this.index, n.level = this.level, n.parentKey = this.parentNode instanceof W ? this.parentNode.node.key : null;
+    var o;
+    n.prevKey = (o = (e = this.previousVisibleSibling) === null || e === void 0 ? void 0 : e.node.key) !== null && o !== void 0 ? o : null;
+    var c;
+    n.nextKey = (c = l?.node.key) !== null && c !== void 0 ? c : null, n.hasChildNodes = !!this.firstChild;
+    var u;
+    n.firstChildKey = (u = (t = this.firstVisibleChild) === null || t === void 0 ? void 0 : t.node.key) !== null && u !== void 0 ? u : null;
+    var v;
+    if (n.lastChildKey = (v = (i = this.lastVisibleChild) === null || i === void 0 ? void 0 : i.node.key) !== null && v !== void 0 ? v : null, (n.colSpan != null || n.colIndex != null) && l) {
+      var $, d;
+      let f = (($ = n.colIndex) !== null && $ !== void 0 ? $ : n.index) + ((d = n.colSpan) !== null && d !== void 0 ? d : 1);
+      if (f !== l.node.colIndex) {
+        let h = l.getMutableNode();
+        h.colIndex = f;
+      }
+    }
+  }
+  setProps(e, t, i, l) {
+    let n = this.getMutableNode(), { value: o, textValue: c, id: u, ...v } = e;
+    if (v.ref = t, n.props = v, n.rendered = i, n.render = l, n.value = o, n.textValue = c || (typeof v.children == "string" ? v.children : "") || e["aria-label"] || "", u != null && u !== n.key) {
+      if (this.hasSetProps) throw new Error("Cannot change the id of an item");
+      n.key = u;
+    }
+    v.colSpan != null && (n.colSpan = v.colSpan), this.hasSetProps = !0, 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, n;
+          (((l = e.parentNode) === null || l === void 0 ? void 0 : l.firstVisibleChild) === e || ((n = e.parentNode) === null || n === void 0 ? void 0 : n.lastVisibleChild) === e) && e.ownerDocument.markDirty(e.parentNode);
+          let o = e.previousVisibleSibling, c = e.nextVisibleSibling;
+          o && e.ownerDocument.markDirty(o), 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.hasSetProps = !1, this.isHidden = !1, this.node = new $e(e, `react-aria-${++t.nodeId}`);
+  }
+}
+class Gt extends et {
+  get isConnected() {
+    return this.isMounted;
+  }
+  createElement(e) {
+    return new W(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 n of this.dirtyNodes) n instanceof W && (!n.isConnected || n.isHidden) ? this.removeNode(n) : n.updateChildIndices();
+    for (let n of this.dirtyNodes) n instanceof W && (n.isConnected && !n.isHidden && (n.updateNode(), this.addNode(n)), n.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(r) {
+  let { children: e, items: t, idScope: i, addIdAndValue: l, dependencies: n = [] } = r, o = B(() => /* @__PURE__ */ new WeakMap(), n);
+  return B(() => {
+    if (t && typeof e == "function") {
+      let v = [];
+      for (let $ of t) {
+        let d = o.get($);
+        if (!d) {
+          d = e($);
+          var c, u;
+          let f = (u = (c = d.props.id) !== null && c !== void 0 ? c : $.key) !== null && u !== void 0 ? u : $.id;
+          if (f == null) throw new Error("Could not determine key for item");
+          i && (f = i + ":" + f), d = qe(d, l ? {
+            key: f,
+            id: f,
+            value: $
+          } : {
+            key: f
+          }), o.set($, d);
+        }
+        v.push(d);
+      }
+      return v;
+    } else if (typeof e != "function") return e;
+  }, [
+    e,
+    t,
+    o,
+    i,
+    l
+  ]);
+}
+const it = /* @__PURE__ */ G(!1), J = /* @__PURE__ */ G(null);
+function Ei(r) {
+  if (H(J))
+    return r.content;
+  let { collection: t, document: i } = Xt(r.createCollection);
+  return /* @__PURE__ */ S.createElement(S.Fragment, null, /* @__PURE__ */ S.createElement($t, null, /* @__PURE__ */ S.createElement(J.Provider, {
+    value: i
+  }, r.content)), /* @__PURE__ */ S.createElement(_t, {
+    render: r.children,
+    collection: t
+  }));
+}
+function _t({ collection: r, render: e }) {
+  return e(r);
+}
+function jt(r, e, t) {
+  let i = Xe(), l = E(i);
+  l.current = i;
+  let n = Z(() => l.current ? t() : e(), [
+    e,
+    t
+  ]);
+  return Wt.useSyncExternalStore(r, n);
+}
+const Yt = typeof S.useSyncExternalStore == "function" ? S.useSyncExternalStore : jt;
+function Xt(r) {
+  let [e] = Y(() => new Gt(r?.() || new xe())), t = Z((o) => e.subscribe(o), [
+    e
+  ]), i = Z(() => {
+    let o = e.getCollection();
+    return e.isSSR && e.resetAfterSSR(), o;
+  }, [
+    e
+  ]), l = Z(() => (e.isSSR = !0, e.getCollection()), [
+    e
+  ]), n = Yt(t, i, l);
+  return me(() => (e.isMounted = !0, () => {
+    e.isMounted = !1;
+  }), [
+    e
+  ]), {
+    collection: n,
+    document: e
+  };
+}
+const Ke = /* @__PURE__ */ G(null);
+function lt(r, e, t, i, l, n) {
+  let o = Z((u) => {
+    u?.setProps(e, t, i, n);
+  }, [
+    e,
+    t,
+    i,
+    n
+  ]), c = H(Ke);
+  if (c) {
+    let u = c.ownerDocument.nodesByProps.get(e);
+    return u || (u = c.ownerDocument.createElement(r), u.setProps(e, t, i, n), c.appendChild(u), c.ownerDocument.updateCollection(), c.ownerDocument.nodesByProps.set(e, u)), l ? /* @__PURE__ */ S.createElement(Ke.Provider, {
+      value: u
+    }, l) : null;
+  }
+  return /* @__PURE__ */ S.createElement(r, {
+    ref: o
+  }, l);
+}
+function ki(r, e) {
+  let t = ({ node: l }) => e(l.props, l.props.ref, l), i = We((l, n) => {
+    let o = H(Pe);
+    if (!H(it)) {
+      if (e.length >= 3) throw new Error(e.name + " cannot be rendered outside a collection.");
+      return e(l, n);
+    }
+    return lt(r, l, n, "children" in l ? l.children : null, null, (u) => (
+      // Forward FocusableContext to real DOM tree so tooltips work.
+      /* @__PURE__ */ S.createElement(Pe.Provider, {
+        value: o
+      }, /* @__PURE__ */ S.createElement(t, {
+        node: u
+      }))
+    ));
+  });
+  return i.displayName = e.name, i;
+}
+function Ii(r, e, t = nt) {
+  let i = ({ node: n }) => e(n.props, n.props.ref, n), l = We((n, o) => {
+    let c = t(n);
+    var u;
+    return (u = lt(r, n, o, null, c, (v) => /* @__PURE__ */ S.createElement(i, {
+      node: v
+    }))) !== null && u !== void 0 ? u : /* @__PURE__ */ S.createElement(S.Fragment, null);
+  });
+  return l.displayName = e.name, l;
+}
+function nt(r) {
+  return tt({
+    ...r,
+    addIdAndValue: !0
+  });
+}
+const ze = /* @__PURE__ */ G(null);
+function Pi(r) {
+  let e = H(ze), t = (e?.dependencies || []).concat(r.dependencies), i = r.idScope || e?.idScope, l = nt({
+    ...r,
+    idScope: i,
+    dependencies: t
+  });
+  return H(J) && (l = /* @__PURE__ */ S.createElement(Zt, null, l)), e = B(() => ({
+    dependencies: t,
+    idScope: i
+  }), [
+    i,
+    ...t
+  ]), /* @__PURE__ */ S.createElement(ze.Provider, {
+    value: e
+  }, l);
+}
+function Zt({ children: r }) {
+  let e = H(J), t = B(() => /* @__PURE__ */ S.createElement(J.Provider, {
+    value: null
+  }, /* @__PURE__ */ S.createElement(it.Provider, {
+    value: !0
+  }, r)), [
+    r
+  ]);
+  return Xe() ? /* @__PURE__ */ S.createElement(Ke.Provider, {
+    value: e
+  }, t) : /* @__PURE__ */ ft(t, e);
+}
+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 Jt(r, e) {
+  if (r.size !== e.size) return !1;
+  for (let t of r)
+    if (!e.has(t)) return !1;
+  return !0;
+}
+function Fi(r) {
+  let { selectionMode: e = "none", disallowEmptySelection: t = !1, allowDuplicateSelectionEvents: i, selectionBehavior: l = "toggle", disabledBehavior: n = "all" } = r, o = E(!1), [, c] = Y(!1), u = E(null), v = E(null), [, $] = Y(null), d = B(() => Ue(r.selectedKeys), [
+    r.selectedKeys
+  ]), f = B(() => Ue(r.defaultSelectedKeys, new R()), [
+    r.defaultSelectedKeys
+  ]), [h, p] = xt(d, f, r.onSelectionChange), K = B(() => r.disabledKeys ? new Set(r.disabledKeys) : /* @__PURE__ */ new Set(), [
+    r.disabledKeys
+  ]), [g, m] = Y(l);
+  l === "replace" && g === "toggle" && typeof h == "object" && h.size === 0 && m("replace");
+  let C = E(l);
+  return X(() => {
+    l !== C.current && (m(l), C.current = l);
+  }, [
+    l
+  ]), {
+    selectionMode: e,
+    disallowEmptySelection: t,
+    selectionBehavior: g,
+    setSelectionBehavior: m,
+    get isFocused() {
+      return o.current;
+    },
+    setFocused(x) {
+      o.current = x, c(x);
+    },
+    get focusedKey() {
+      return u.current;
+    },
+    get childFocusStrategy() {
+      return v.current;
+    },
+    setFocusedKey(x, k = "first") {
+      u.current = x, v.current = k, $(x);
+    },
+    selectedKeys: h,
+    setSelectedKeys(x) {
+      (i || !Jt(x, h)) && p(x);
+    },
+    disabledKeys: K,
+    disabledBehavior: n
+  };
+}
+function Ue(r, e) {
+  return r ? r === "all" ? "all" : new R(r) : 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 o = this.state.selectedKeys;
+      var l;
+      let c = (l = o.anchorKey) !== null && l !== void 0 ? l : t;
+      i = new R(o, c, t);
+      var n;
+      for (let u of this.getKeyRange(c, (n = o.currentKey) !== null && n !== void 0 ? n : 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 = [], n = e;
+    for (; n != null; ) {
+      let o = this.collection.getItem(n);
+      if (o && (o.type === "item" || o.type === "cell" && this.allowsCellSelection) && l.push(n), n === t) return l;
+      n = this.collection.getKeyAfter(n);
+    }
+    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 o = this.collection.getItem(i);
+          o?.type === "item" && e.push(i);
+          var n;
+          o?.hasChildNodes && (this.allowsCellSelection || o.type !== "item") && t((n = (l = Nt(Vt(o, this.collection))) === null || l === void 0 ? void 0 : l.key) !== null && n !== void 0 ? n : 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;
+  }
+}
+const Mi = /* @__PURE__ */ G(null), Qt = {
+  CollectionRoot({ collection: r, renderDropIndicator: e }) {
+    return He(r, null, e);
+  },
+  CollectionBranch({ collection: r, parent: e, renderDropIndicator: t }) {
+    return He(r, e, t);
+  }
+};
+function He(r, e, t) {
+  return tt({
+    items: e ? r.getChildren(e.key) : r,
+    dependencies: [
+      t
+    ],
+    children(i) {
+      let l = i.render(i);
+      return !t || i.type !== "item" ? l : /* @__PURE__ */ S.createElement(S.Fragment, null, t({
+        type: "item",
+        key: i.key,
+        dropPosition: "before"
+      }), l, ei(r, i, t));
+    }
+  });
+}
+function ei(r, e, t) {
+  let i = e.key, l = r.getKeyAfter(i), n = l != null ? r.getItem(l) : null;
+  for (; n != null && n.type !== "item"; )
+    l = r.getKeyAfter(n.key), n = l != null ? r.getItem(l) : null;
+  let o = e.nextKey != null ? r.getItem(e.nextKey) : null;
+  for (; o != null && o.type !== "item"; ) o = o.nextKey != null ? r.getItem(o.nextKey) : null;
+  let c = [];
+  if (o == null) {
+    let u = e;
+    for (; u && (!n || u.parentKey !== n.parentKey && n.level < u.level); ) {
+      let v = t({
+        type: "item",
+        key: u.key,
+        dropPosition: "after"
+      });
+      /* @__PURE__ */ ot(v) && c.push(/* @__PURE__ */ qe(v, {
+        key: `${u.key}-after`
+      })), u = u.parentKey != null ? r.getItem(u.parentKey) : null;
+    }
+  }
+  return c;
+}
+const Ai = /* @__PURE__ */ G(Qt);
+function Ri(r) {
+  return B(() => r != null ? /* @__PURE__ */ new Set([
+    r
+  ]) : null, [
+    r
+  ]);
+}
+export {
+  xi as $,
+  tt as A,
+  xe as B,
+  $e as C,
+  It as D,
+  Fi as a,
+  wi as b,
+  rt as c,
+  ki as d,
+  Ii as e,
+  Ei as f,
+  Pi as g,
+  Ai as h,
+  Ci as i,
+  Mi as j,
+  Tt as k,
+  $i as l,
+  Vt as m,
+  wt as n,
+  Ze as o,
+  Ct as p,
+  Pt as q,
+  Je as r,
+  q as s,
+  Ft as t,
+  Qt as u,
+  Ri as v,
+  Di as w,
+  Nt as x,
+  zt as y,
+  Re as z
+};
+//# sourceMappingURL=Collection-CDJ_uFKV.es.js.map