@commercetools/nimbus 0.0.11 → 1.0.0

package/dist/chunks/data-table-CSWloD1b.es.js

@@ -0,0 +1,3912 @@
+import { jsx as D, jsxs as ne, Fragment as it } from "react/jsx-runtime";
+import w, { useRef as M, useMemo as T, useCallback as O, useEffect as oe, useState as G, forwardRef as Y, createContext as ie, useContext as A, Fragment as ml } from "react";
+import { $ as at } from "./Button-C-yUWwZg.es.js";
+import { $ as ut } from "./RSPContexts-B4yvXuBR.es.js";
+import { m as W, w as le, x as te, y as ke, z as gl, l as bl, $ as st, a as dt, c as vl, b as yl, e as Fe, d as ct, g as $e, f as $l, A as xl, h as Z, u as ft, B as Dl, C as Ze, i as Cl } from "./Collection-DFZhstai.es.js";
+import { $ as wl, a as re, d as ze, g as Je, f as kl } from "./utils-BkdW_cdL.es.js";
+import { $ as fe, a as Sl, b as El, c as zl, d as Wo, e as Vo } from "./DragAndDrop-ChYb3tCX.es.js";
+import { $ as Al } from "./intlStrings-Cd44R5hT.es.js";
+import { d as ve, a as Ae, $ as H, e as Rl, c as Qe } from "./mergeProps-B_9syxhT.es.js";
+import { $ as J } from "./filterDOMProps-BSVCO5jK.es.js";
+import { $ as ae } from "./useObjectRef-CaJ5pgjX.es.js";
+import { $ as Bl } from "./useResizeObserver-FIPBIG5S.es.js";
+import { c as ue, $ as se, a as Ie, d as Pl } from "./scrollIntoView-BYF_8_6g.es.js";
+import Kl from "react-dom";
+import { $ as xe } from "./useHover-cJOf02TT.es.js";
+import { d as _e } from "./platform-Z5fvtFmM.es.js";
+import { a as Ml, b as Tl, $ as pt } from "./usePress-BquTSwUd.es.js";
+import { $ as Nl, c as Fl } from "./useFocusable-BghVNiQU.es.js";
+import { $ as Il, f as Wl } from "./useFocusVisible-C5ivHvqm.es.js";
+import { $ as q } from "./focusSafely-Di2ArC9L.es.js";
+import { b as et, a as Vl } from "./FocusScope-C1Aw7j9H.es.js";
+import { $ as pe } from "./context-Pt-0ojuK.es.js";
+import { $ as he } from "./useLocalizedStringFormatter-CvzOUusg.es.js";
+import { $ as ce } from "./useFocusRing-D8cwV0EM.es.js";
+import { $ as Hl } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { a as Re, $ as tt } from "./VisuallyHidden-C38kRNm0.es.js";
+import { e as jl } from "./openLink-Ctl0AdAy.es.js";
+import { m as Ee } from "./utils-Gg3iiYhl.es.js";
+import { $ as Ol, a as Ul, b as Ll, c as Yl } from "./useHighlightSelectionDescription-DAR8wV79.es.js";
+import { $ as Xl } from "./LiveAnnouncer-CsPyaceH.es.js";
+import { $ as ht } from "./useCollator-BvjDbml1.es.js";
+import { $ as ql } from "./useUpdateEffect-CCDx8D4X.es.js";
+import { B as ye } from "./box-7pkPaNxe.es.js";
+import { defineSlotRecipe as Gl, createSlotRecipeContext as Zl, mergeRefs as Jl } from "@chakra-ui/react";
+import { B as Ql } from "./button-D5pgTe6f.es.js";
+import { I as _l } from "./icon-button-C2GGAKhI.es.js";
+import { C as mt } from "./checkbox-BJQlCxDq.es.js";
+import { KeyboardArrowDown as en, KeyboardArrowRight as tn, ContentCopy as ln, ArrowDownward as nn } from "@commercetools/nimbus-icons";
+import { c as on } from "./create-recipe-context-BuajKZ9o.es.js";
+import { F as gt } from "./flex-9fkV4bsm.es.js";
+import { D as rn } from "./divider-DMH0p6Pr.es.js";
+function an(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+function un(t) {
+  let { onMoveStart: e, onMove: l, onMoveEnd: n } = t, o = M({
+    didMove: !1,
+    lastPosition: null,
+    id: null
+  }), { addGlobalListener: r, removeGlobalListener: i } = Hl(), u = ve((d, s, p, f) => {
+    p === 0 && f === 0 || (o.current.didMove || (o.current.didMove = !0, e?.({
+      type: "movestart",
+      pointerType: s,
+      shiftKey: d.shiftKey,
+      metaKey: d.metaKey,
+      ctrlKey: d.ctrlKey,
+      altKey: d.altKey
+    })), l?.({
+      type: "move",
+      pointerType: s,
+      deltaX: p,
+      deltaY: f,
+      shiftKey: d.shiftKey,
+      metaKey: d.metaKey,
+      ctrlKey: d.ctrlKey,
+      altKey: d.altKey
+    }));
+  }), a = ve((d, s) => {
+    Ml(), o.current.didMove && n?.({
+      type: "moveend",
+      pointerType: s,
+      shiftKey: d.shiftKey,
+      metaKey: d.metaKey,
+      ctrlKey: d.ctrlKey,
+      altKey: d.altKey
+    });
+  });
+  return {
+    moveProps: T(() => {
+      let d = {}, s = () => {
+        Tl(), o.current.didMove = !1;
+      };
+      if (typeof PointerEvent > "u" && process.env.NODE_ENV === "test") {
+        let f = (v) => {
+          if (v.button === 0) {
+            var x, m, $, b;
+            u(v, "mouse", v.pageX - (($ = (x = o.current.lastPosition) === null || x === void 0 ? void 0 : x.pageX) !== null && $ !== void 0 ? $ : 0), v.pageY - ((b = (m = o.current.lastPosition) === null || m === void 0 ? void 0 : m.pageY) !== null && b !== void 0 ? b : 0)), o.current.lastPosition = {
+              pageX: v.pageX,
+              pageY: v.pageY
+            };
+          }
+        }, h = (v) => {
+          v.button === 0 && (a(v, "mouse"), i(window, "mousemove", f, !1), i(window, "mouseup", h, !1));
+        };
+        d.onMouseDown = (v) => {
+          v.button === 0 && (s(), v.stopPropagation(), v.preventDefault(), o.current.lastPosition = {
+            pageX: v.pageX,
+            pageY: v.pageY
+          }, r(window, "mousemove", f, !1), r(window, "mouseup", h, !1));
+        };
+        let g = (v) => {
+          let x = [
+            ...v.changedTouches
+          ].findIndex(({ identifier: k }) => k === o.current.id);
+          if (x >= 0) {
+            var m, $;
+            let { pageX: k, pageY: P } = v.changedTouches[x];
+            var b, C;
+            u(v, "touch", k - ((b = (m = o.current.lastPosition) === null || m === void 0 ? void 0 : m.pageX) !== null && b !== void 0 ? b : 0), P - ((C = ($ = o.current.lastPosition) === null || $ === void 0 ? void 0 : $.pageY) !== null && C !== void 0 ? C : 0)), o.current.lastPosition = {
+              pageX: k,
+              pageY: P
+            };
+          }
+        }, y = (v) => {
+          [
+            ...v.changedTouches
+          ].findIndex(({ identifier: m }) => m === o.current.id) >= 0 && (a(v, "touch"), o.current.id = null, i(window, "touchmove", g), i(window, "touchend", y), i(window, "touchcancel", y));
+        };
+        d.onTouchStart = (v) => {
+          if (v.changedTouches.length === 0 || o.current.id != null) return;
+          let { pageX: x, pageY: m, identifier: $ } = v.changedTouches[0];
+          s(), v.stopPropagation(), v.preventDefault(), o.current.lastPosition = {
+            pageX: x,
+            pageY: m
+          }, o.current.id = $, r(window, "touchmove", g, !1), r(window, "touchend", y, !1), r(window, "touchcancel", y, !1);
+        };
+      } else {
+        let f = (g) => {
+          if (g.pointerId === o.current.id) {
+            var y, v;
+            let $ = g.pointerType || "mouse";
+            var x, m;
+            u(g, $, g.pageX - ((x = (y = o.current.lastPosition) === null || y === void 0 ? void 0 : y.pageX) !== null && x !== void 0 ? x : 0), g.pageY - ((m = (v = o.current.lastPosition) === null || v === void 0 ? void 0 : v.pageY) !== null && m !== void 0 ? m : 0)), o.current.lastPosition = {
+              pageX: g.pageX,
+              pageY: g.pageY
+            };
+          }
+        }, h = (g) => {
+          if (g.pointerId === o.current.id) {
+            let y = g.pointerType || "mouse";
+            a(g, y), o.current.id = null, i(window, "pointermove", f, !1), i(window, "pointerup", h, !1), i(window, "pointercancel", h, !1);
+          }
+        };
+        d.onPointerDown = (g) => {
+          g.button === 0 && o.current.id == null && (s(), g.stopPropagation(), g.preventDefault(), o.current.lastPosition = {
+            pageX: g.pageX,
+            pageY: g.pageY
+          }, o.current.id = g.pointerId, r(window, "pointermove", f, !1), r(window, "pointerup", h, !1), r(window, "pointercancel", h, !1));
+        };
+      }
+      let p = (f, h, g) => {
+        s(), u(f, "keyboard", h, g), a(f, "keyboard");
+      };
+      return d.onKeyDown = (f) => {
+        switch (f.key) {
+          case "Left":
+          case "ArrowLeft":
+            f.preventDefault(), f.stopPropagation(), p(f, -1, 0);
+            break;
+          case "Right":
+          case "ArrowRight":
+            f.preventDefault(), f.stopPropagation(), p(f, 1, 0);
+            break;
+          case "Up":
+          case "ArrowUp":
+            f.preventDefault(), f.stopPropagation(), p(f, 0, -1);
+            break;
+          case "Down":
+          case "ArrowDown":
+            f.preventDefault(), f.stopPropagation(), p(f, 0, 1);
+            break;
+        }
+      }, d;
+    }, [
+      o,
+      r,
+      i,
+      u,
+      a
+    ])
+  };
+}
+class bt {
+  isCell(e) {
+    return e.type === "cell";
+  }
+  isRow(e) {
+    return e.type === "row" || e.type === "item";
+  }
+  isDisabled(e) {
+    var l;
+    return this.disabledBehavior === "all" && (((l = e.props) === null || l === void 0 ? void 0 : l.isDisabled) || this.disabledKeys.has(e.key));
+  }
+  findPreviousKey(e, l) {
+    let n = e != null ? this.collection.getKeyBefore(e) : this.collection.getLastKey();
+    for (; n != null; ) {
+      let o = this.collection.getItem(n);
+      if (!o) return null;
+      if (!this.isDisabled(o) && (!l || l(o))) return n;
+      n = this.collection.getKeyBefore(n);
+    }
+    return null;
+  }
+  findNextKey(e, l) {
+    let n = e != null ? this.collection.getKeyAfter(e) : this.collection.getFirstKey();
+    for (; n != null; ) {
+      let o = this.collection.getItem(n);
+      if (!o) return null;
+      if (!this.isDisabled(o) && (!l || l(o))) return n;
+      if (n = this.collection.getKeyAfter(n), n == null) return null;
+    }
+    return null;
+  }
+  getKeyForItemInRowByIndex(e, l = 0) {
+    if (l < 0) return null;
+    let n = this.collection.getItem(e);
+    if (!n) return null;
+    let o = 0;
+    for (let u of W(n, this.collection)) {
+      var r;
+      if (u.colSpan && u.colSpan + o > l) return (r = u.key) !== null && r !== void 0 ? r : null;
+      u.colSpan && (o = o + u.colSpan - 1);
+      var i;
+      if (o === l) return (i = u.key) !== null && i !== void 0 ? i : null;
+      o++;
+    }
+    return null;
+  }
+  getKeyBelow(e) {
+    let l = e, n = this.collection.getItem(l);
+    if (!n) return null;
+    var o;
+    if (this.isCell(n) && (l = (o = n.parentKey) !== null && o !== void 0 ? o : null), l == null) return null;
+    if (l = this.findNextKey(l, (r) => r.type === "item"), l != null) {
+      if (this.isCell(n)) {
+        let r = n.colIndex ? n.colIndex : n.index;
+        return this.getKeyForItemInRowByIndex(l, r);
+      }
+      if (this.focusMode === "row") return l;
+    }
+    return null;
+  }
+  getKeyAbove(e) {
+    let l = e, n = this.collection.getItem(l);
+    if (!n) return null;
+    var o;
+    if (this.isCell(n) && (l = (o = n.parentKey) !== null && o !== void 0 ? o : null), l == null) return null;
+    if (l = this.findPreviousKey(l, (r) => r.type === "item"), l != null) {
+      if (this.isCell(n)) {
+        let r = n.colIndex ? n.colIndex : n.index;
+        return this.getKeyForItemInRowByIndex(l, r);
+      }
+      if (this.focusMode === "row") return l;
+    }
+    return null;
+  }
+  getKeyRightOf(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (this.isRow(l)) {
+      var n, o;
+      let d = W(l, this.collection);
+      var r;
+      return (r = this.direction === "rtl" ? (n = le(d)) === null || n === void 0 ? void 0 : n.key : (o = te(d)) === null || o === void 0 ? void 0 : o.key) !== null && r !== void 0 ? r : null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let d = this.collection.getItem(l.parentKey);
+      if (!d) return null;
+      let s = W(d, this.collection);
+      var i;
+      let p = (i = this.direction === "rtl" ? ke(s, l.index - 1) : ke(s, l.index + 1)) !== null && i !== void 0 ? i : null;
+      var u;
+      if (p) return (u = p.key) !== null && u !== void 0 ? u : null;
+      var a;
+      if (this.focusMode === "row") return (a = l.parentKey) !== null && a !== void 0 ? a : null;
+      var c;
+      return (c = this.direction === "rtl" ? this.getFirstKey(e) : this.getLastKey(e)) !== null && c !== void 0 ? c : null;
+    }
+    return null;
+  }
+  getKeyLeftOf(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (this.isRow(l)) {
+      var n, o;
+      let d = W(l, this.collection);
+      var r;
+      return (r = this.direction === "rtl" ? (n = te(d)) === null || n === void 0 ? void 0 : n.key : (o = le(d)) === null || o === void 0 ? void 0 : o.key) !== null && r !== void 0 ? r : null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let d = this.collection.getItem(l.parentKey);
+      if (!d) return null;
+      let s = W(d, this.collection);
+      var i;
+      let p = (i = this.direction === "rtl" ? ke(s, l.index + 1) : ke(s, l.index - 1)) !== null && i !== void 0 ? i : null;
+      var u;
+      if (p) return (u = p.key) !== null && u !== void 0 ? u : null;
+      var a;
+      if (this.focusMode === "row") return (a = l.parentKey) !== null && a !== void 0 ? a : null;
+      var c;
+      return (c = this.direction === "rtl" ? this.getLastKey(e) : this.getFirstKey(e)) !== null && c !== void 0 ? c : null;
+    }
+    return null;
+  }
+  getFirstKey(e, l) {
+    let n = e ?? null, o;
+    if (n != null) {
+      if (o = this.collection.getItem(n), !o) return null;
+      if (this.isCell(o) && !l && o.parentKey != null) {
+        var r;
+        let c = this.collection.getItem(o.parentKey);
+        if (!c) return null;
+        var i;
+        return (i = (r = te(W(c, this.collection))) === null || r === void 0 ? void 0 : r.key) !== null && i !== void 0 ? i : null;
+      }
+    }
+    if (n = this.findNextKey(void 0, (c) => c.type === "item"), n != null && (o && this.isCell(o) && l || this.focusMode === "cell")) {
+      var u;
+      let c = this.collection.getItem(n);
+      if (!c) return null;
+      var a;
+      n = (a = (u = te(W(c, this.collection))) === null || u === void 0 ? void 0 : u.key) !== null && a !== void 0 ? a : null;
+    }
+    return n;
+  }
+  getLastKey(e, l) {
+    let n = e ?? null, o;
+    if (n != null) {
+      if (o = this.collection.getItem(n), !o) return null;
+      if (this.isCell(o) && !l && o.parentKey != null) {
+        var r;
+        let c = this.collection.getItem(o.parentKey);
+        if (!c) return null;
+        let d = W(c, this.collection);
+        var i;
+        return (i = (r = le(d)) === null || r === void 0 ? void 0 : r.key) !== null && i !== void 0 ? i : null;
+      }
+    }
+    if (n = this.findPreviousKey(void 0, (c) => c.type === "item"), n != null && (o && this.isCell(o) && l || this.focusMode === "cell")) {
+      var u;
+      let c = this.collection.getItem(n);
+      if (!c) return null;
+      let d = W(c, this.collection);
+      var a;
+      n = (a = (u = le(d)) === null || u === void 0 ? void 0 : u.key) !== null && a !== void 0 ? a : null;
+    }
+    return n;
+  }
+  getKeyPageAbove(e) {
+    let l = e, n = this.layoutDelegate.getItemRect(l);
+    if (!n) return null;
+    let o = Math.max(0, n.y + n.height - this.layoutDelegate.getVisibleRect().height);
+    for (; n && n.y > o && l != null; ) {
+      var r;
+      if (l = (r = this.getKeyAbove(l)) !== null && r !== void 0 ? r : null, l == null) break;
+      n = this.layoutDelegate.getItemRect(l);
+    }
+    return l;
+  }
+  getKeyPageBelow(e) {
+    let l = e, n = this.layoutDelegate.getItemRect(l);
+    if (!n) return null;
+    let o = this.layoutDelegate.getVisibleRect().height, r = Math.min(this.layoutDelegate.getContentSize().height, n.y + o);
+    for (; n && n.y + n.height < r; ) {
+      let i = this.getKeyBelow(l);
+      if (i == null) break;
+      n = this.layoutDelegate.getItemRect(i), l = i;
+    }
+    return l;
+  }
+  getKeyForSearch(e, l) {
+    let n = l ?? null;
+    if (!this.collator) return null;
+    let o = this.collection;
+    if (n = l ?? this.getFirstKey(), n == null) return null;
+    let r = o.getItem(n);
+    if (!r) return null;
+    var i;
+    r.type === "cell" && (n = (i = r.parentKey) !== null && i !== void 0 ? i : null);
+    let u = !1;
+    for (; n != null; ) {
+      let d = o.getItem(n);
+      if (!d) return null;
+      if (d.textValue) {
+        let s = d.textValue.slice(0, e.length);
+        if (this.collator.compare(s, e) === 0) {
+          var a, c;
+          return this.isRow(d) && this.focusMode === "cell" ? (c = (a = te(W(d, this.collection))) === null || a === void 0 ? void 0 : a.key) !== null && c !== void 0 ? c : null : d.key;
+        }
+      }
+      n = this.findNextKey(n, (s) => s.type === "item"), n == null && !u && (n = this.getFirstKey(), u = !0);
+    }
+    return null;
+  }
+  constructor(e) {
+    if (this.collection = e.collection, this.disabledKeys = e.disabledKeys, this.disabledBehavior = e.disabledBehavior || "all", this.direction = e.direction, this.collator = e.collator, !e.layout && !e.ref) throw new Error("Either a layout or a ref must be specified.");
+    this.layoutDelegate = e.layoutDelegate || (e.layout ? new sn(e.layout) : new gl(e.ref));
+    var l;
+    this.focusMode = (l = e.focusMode) !== null && l !== void 0 ? l : "row";
+  }
+}
+class sn {
+  getContentSize() {
+    return this.layout.getContentSize();
+  }
+  getItemRect(e) {
+    var l;
+    return ((l = this.layout.getLayoutInfo(e)) === null || l === void 0 ? void 0 : l.rect) || null;
+  }
+  getVisibleRect() {
+    return this.layout.virtualizer.visibleRect;
+  }
+  constructor(e) {
+    this.layout = e;
+  }
+}
+const We = /* @__PURE__ */ new WeakMap();
+function dn(t, e, l) {
+  let { isVirtualized: n, disallowTypeAhead: o, keyboardDelegate: r, focusMode: i, scrollRef: u, getRowText: a, onRowAction: c, onCellAction: d, escapeKeyBehavior: s = "clearSelection", shouldSelectOnPressUp: p } = t, { selectionManager: f } = e;
+  !t["aria-label"] && !t["aria-labelledby"] && console.warn("An aria-label or aria-labelledby prop is required for accessibility.");
+  let h = ht({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: g } = pe(), y = e.selectionManager.disabledBehavior, v = T(() => r || new bt({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: y,
+    ref: l,
+    direction: g,
+    collator: h,
+    focusMode: i
+  }), [
+    r,
+    e.collection,
+    e.disabledKeys,
+    y,
+    l,
+    g,
+    h,
+    i
+  ]), { collectionProps: x } = bl({
+    ref: l,
+    selectionManager: f,
+    keyboardDelegate: v,
+    isVirtualized: n,
+    scrollRef: u,
+    disallowTypeAhead: o,
+    escapeKeyBehavior: s
+  }), m = Ae(t.id);
+  We.set(e, {
+    keyboardDelegate: v,
+    actions: {
+      onRowAction: c,
+      onCellAction: d
+    },
+    shouldSelectOnPressUp: p
+  });
+  let $ = Ol({
+    selectionManager: f,
+    hasItemActions: !!(c || d)
+  }), b = J(t, {
+    labelable: !0
+  }), C = O((E) => {
+    if (f.isFocused) {
+      E.currentTarget.contains(E.target) || f.setFocused(!1);
+      return;
+    }
+    E.currentTarget.contains(E.target) && f.setFocused(!0);
+  }, [
+    f
+  ]), k = T(() => ({
+    onBlur: x.onBlur,
+    onFocus: C
+  }), [
+    C,
+    x.onBlur
+  ]), P = Ul(l, {
+    isDisabled: e.collection.size !== 0
+  }), K = H(
+    b,
+    {
+      role: "grid",
+      id: m,
+      "aria-multiselectable": f.selectionMode === "multiple" ? "true" : void 0
+    },
+    e.isKeyboardNavigationDisabled ? k : x,
+    // If collection is empty, make sure the grid is tabbable unless there is a child tabbable element.
+    e.collection.size === 0 && {
+      tabIndex: P ? -1 : 0
+    } || void 0,
+    $
+  );
+  return n && (K["aria-rowcount"] = e.collection.size, K["aria-colcount"] = e.collection.columnCount), Ll({
+    getRowText: a
+  }, e), {
+    gridProps: K
+  };
+}
+function cn() {
+  return {
+    rowGroupProps: {
+      role: "rowgroup"
+    }
+  };
+}
+function fn(t, e, l) {
+  var n, o;
+  let { node: r, isVirtualized: i, shouldSelectOnPressUp: u, onAction: a } = t, { actions: c, shouldSelectOnPressUp: d } = We.get(e), s = c.onRowAction ? () => {
+    var y;
+    return (y = c.onRowAction) === null || y === void 0 ? void 0 : y.call(c, r.key);
+  } : a, { itemProps: p, ...f } = st({
+    selectionManager: e.selectionManager,
+    key: r.key,
+    ref: l,
+    isVirtualized: i,
+    shouldSelectOnPressUp: d || u,
+    onAction: s || !(r == null || (n = r.props) === null || n === void 0) && n.onAction ? Rl(r == null || (o = r.props) === null || o === void 0 ? void 0 : o.onAction, s) : void 0,
+    isDisabled: e.collection.size === 0
+  }), h = e.selectionManager.isSelected(r.key), g = {
+    role: "row",
+    "aria-selected": e.selectionManager.selectionMode !== "none" ? h : void 0,
+    "aria-disabled": f.isDisabled || void 0,
+    ...p
+  };
+  return i && (g["aria-rowindex"] = r.index + 1), {
+    rowProps: g,
+    ...f
+  };
+}
+function vt(t, e, l) {
+  let { node: n, isVirtualized: o, focusMode: r = "child", shouldSelectOnPressUp: i, onAction: u } = t, { direction: a } = pe(), { keyboardDelegate: c, actions: { onCellAction: d } } = We.get(e), s = M(null), p = () => {
+    if (l.current) {
+      let m = et(l.current);
+      if (r === "child") {
+        if (l.current.contains(document.activeElement) && l.current !== document.activeElement) return;
+        let $ = e.selectionManager.childFocusStrategy === "last" ? Pe(m) : m.firstChild();
+        if ($) {
+          q($);
+          return;
+        }
+      }
+      (s.current != null && n.key !== s.current || !l.current.contains(document.activeElement)) && q(l.current);
+    }
+  }, { itemProps: f, isPressed: h } = st({
+    selectionManager: e.selectionManager,
+    key: n.key,
+    ref: l,
+    isVirtualized: o,
+    focus: p,
+    shouldSelectOnPressUp: i,
+    onAction: d ? () => d(n.key) : u,
+    isDisabled: e.collection.size === 0
+  }), g = (m) => {
+    if (!m.currentTarget.contains(m.target) || e.isKeyboardNavigationDisabled || !l.current || !document.activeElement) return;
+    let $ = et(l.current);
+    switch ($.currentNode = document.activeElement, m.key) {
+      case "ArrowLeft": {
+        let E = a === "rtl" ? $.nextNode() : $.previousNode();
+        if (r === "child" && E === l.current && (E = null), m.preventDefault(), m.stopPropagation(), E)
+          q(E), ue(E, {
+            containingElement: se(l.current)
+          });
+        else {
+          var b;
+          if (((b = c.getKeyLeftOf) === null || b === void 0 ? void 0 : b.call(c, n.key)) !== n.key) {
+            var C;
+            (C = l.current.parentElement) === null || C === void 0 || C.dispatchEvent(new KeyboardEvent(m.nativeEvent.type, m.nativeEvent));
+            break;
+          }
+          r === "cell" && a === "rtl" ? (q(l.current), ue(l.current, {
+            containingElement: se(l.current)
+          })) : ($.currentNode = l.current, E = a === "rtl" ? $.firstChild() : Pe($), E && (q(E), ue(E, {
+            containingElement: se(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowRight": {
+        let E = a === "rtl" ? $.previousNode() : $.nextNode();
+        if (r === "child" && E === l.current && (E = null), m.preventDefault(), m.stopPropagation(), E)
+          q(E), ue(E, {
+            containingElement: se(l.current)
+          });
+        else {
+          var k;
+          if (((k = c.getKeyRightOf) === null || k === void 0 ? void 0 : k.call(c, n.key)) !== n.key) {
+            var P;
+            (P = l.current.parentElement) === null || P === void 0 || P.dispatchEvent(new KeyboardEvent(m.nativeEvent.type, m.nativeEvent));
+            break;
+          }
+          r === "cell" && a === "ltr" ? (q(l.current), ue(l.current, {
+            containingElement: se(l.current)
+          })) : ($.currentNode = l.current, E = a === "rtl" ? Pe($) : $.firstChild(), E && (q(E), ue(E, {
+            containingElement: se(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowUp":
+      case "ArrowDown":
+        if (!m.altKey && l.current.contains(m.target)) {
+          var K;
+          m.stopPropagation(), m.preventDefault(), (K = l.current.parentElement) === null || K === void 0 || K.dispatchEvent(new KeyboardEvent(m.nativeEvent.type, m.nativeEvent));
+        }
+        break;
+    }
+  }, y = (m) => {
+    if (s.current = n.key, m.target !== l.current) {
+      Il() || e.selectionManager.setFocusedKey(n.key);
+      return;
+    }
+    requestAnimationFrame(() => {
+      r === "child" && document.activeElement === l.current && p();
+    });
+  }, v = H(f, {
+    role: "gridcell",
+    onKeyDownCapture: g,
+    "aria-colspan": n.colSpan,
+    "aria-colindex": n.colIndex != null ? n.colIndex + 1 : void 0,
+    colSpan: o ? void 0 : n.colSpan,
+    onFocus: y
+  });
+  var x;
+  return o && (v["aria-colindex"] = ((x = n.colIndex) !== null && x !== void 0 ? x : n.index) + 1), i && v.tabIndex != null && v.onPointerDown == null && (v.onPointerDown = (m) => {
+    let $ = m.currentTarget, b = $.getAttribute("tabindex");
+    $.removeAttribute("tabindex"), requestAnimationFrame(() => {
+      b != null && $.setAttribute("tabindex", b);
+    });
+  }), {
+    gridCellProps: v,
+    isPressed: h
+  };
+}
+function Pe(t) {
+  let e = null, l = null;
+  do
+    l = t.lastChild(), l && (e = l);
+  while (l);
+  return e;
+}
+function pn(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function hn(t, e) {
+  let { key: l } = t, n = e.selectionManager, o = Ae(), r = !e.selectionManager.canSelectItem(l), i = e.selectionManager.isSelected(l), u = () => n.toggleSelection(l);
+  const a = he(pn(Yl), "@react-aria/grid");
+  return {
+    checkboxProps: {
+      id: o,
+      "aria-label": a.format("select"),
+      isSelected: i,
+      isDisabled: r,
+      onChange: u
+    }
+  };
+}
+const Ve = /* @__PURE__ */ new WeakMap();
+function Te(t) {
+  return typeof t == "string" ? t.replace(/\s*/g, "") : "" + t;
+}
+function yt(t, e) {
+  let l = Ve.get(t);
+  if (!l) throw new Error("Unknown grid");
+  return `${l}-${Te(e)}`;
+}
+function $t(t, e, l) {
+  let n = Ve.get(t);
+  if (!n) throw new Error("Unknown grid");
+  return `${n}-${Te(e)}-${Te(l)}`;
+}
+function xt(t, e) {
+  return [
+    ...t.collection.rowHeaderColumnKeys
+  ].map((l) => $t(t, e, l)).join(" ");
+}
+var Dt = {};
+Dt = {
+  ascending: "تصاعدي",
+  ascendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تصاعدي`,
+  columnSize: (t) => `${t.value} بالبكسل`,
+  descending: "تنازلي",
+  descendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تنازلي`,
+  resizerDescription: "اضغط على مفتاح Enter لبدء تغيير الحجم",
+  select: "تحديد",
+  selectAll: "تحديد الكل",
+  sortable: "عمود قابل للترتيب"
+};
+var Ct = {};
+Ct = {
+  ascending: "възходящ",
+  ascendingSort: (t) => `сортирано по колона ${t.columnName} във възходящ ред`,
+  columnSize: (t) => `${t.value} пиксела`,
+  descending: "низходящ",
+  descendingSort: (t) => `сортирано по колона ${t.columnName} в низходящ ред`,
+  resizerDescription: "Натиснете „Enter“, за да започнете да преоразмерявате",
+  select: "Изберете",
+  selectAll: "Изберете всичко",
+  sortable: "сортираща колона"
+};
+var wt = {};
+wt = {
+  ascending: "vzestupně",
+  ascendingSort: (t) => `řazeno vzestupně podle sloupce ${t.columnName}`,
+  columnSize: (t) => `${t.value} pixelů`,
+  descending: "sestupně",
+  descendingSort: (t) => `řazeno sestupně podle sloupce ${t.columnName}`,
+  resizerDescription: "Stisknutím klávesy Enter začnete měnit velikost",
+  select: "Vybrat",
+  selectAll: "Vybrat vše",
+  sortable: "sloupec s možností řazení"
+};
+var kt = {};
+kt = {
+  ascending: "stigende",
+  ascendingSort: (t) => `sorteret efter kolonne ${t.columnName} i stigende rækkefølge`,
+  columnSize: (t) => `${t.value} pixels`,
+  descending: "faldende",
+  descendingSort: (t) => `sorteret efter kolonne ${t.columnName} i faldende rækkefølge`,
+  resizerDescription: "Tryk på Enter for at ændre størrelse",
+  select: "Vælg",
+  selectAll: "Vælg alle",
+  sortable: "sorterbar kolonne"
+};
+var St = {};
+St = {
+  ascending: "aufsteigend",
+  ascendingSort: (t) => `sortiert nach Spalte ${t.columnName} in aufsteigender Reihenfolge`,
+  columnSize: (t) => `${t.value} Pixel`,
+  descending: "absteigend",
+  descendingSort: (t) => `sortiert nach Spalte ${t.columnName} in absteigender Reihenfolge`,
+  resizerDescription: "Eingabetaste zum Starten der Größenänderung drücken",
+  select: "Auswählen",
+  selectAll: "Alles auswählen",
+  sortable: "sortierbare Spalte"
+};
+var Et = {};
+Et = {
+  ascending: "αύξουσα",
+  ascendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε αύξουσα σειρά`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "φθίνουσα",
+  descendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε φθίνουσα σειρά`,
+  resizerDescription: "Πατήστε Enter για έναρξη της αλλαγής μεγέθους",
+  select: "Επιλογή",
+  selectAll: "Επιλογή όλων",
+  sortable: "Στήλη διαλογής"
+};
+var zt = {};
+zt = {
+  select: "Select",
+  selectAll: "Select All",
+  sortable: "sortable column",
+  ascending: "ascending",
+  descending: "descending",
+  ascendingSort: (t) => `sorted by column ${t.columnName} in ascending order`,
+  descendingSort: (t) => `sorted by column ${t.columnName} in descending order`,
+  columnSize: (t) => `${t.value} pixels`,
+  resizerDescription: "Press Enter to start resizing"
+};
+var At = {};
+At = {
+  ascending: "ascendente",
+  ascendingSort: (t) => `ordenado por columna ${t.columnName} en sentido ascendente`,
+  columnSize: (t) => `${t.value} píxeles`,
+  descending: "descendente",
+  descendingSort: (t) => `ordenado por columna ${t.columnName} en orden descendente`,
+  resizerDescription: "Pulse Intro para empezar a redimensionar",
+  select: "Seleccionar",
+  selectAll: "Seleccionar todos",
+  sortable: "columna ordenable"
+};
+var Rt = {};
+Rt = {
+  ascending: "tõusev järjestus",
+  ascendingSort: (t) => `sorditud veeru järgi ${t.columnName} tõusvas järjestuses`,
+  columnSize: (t) => `${t.value} pikslit`,
+  descending: "laskuv järjestus",
+  descendingSort: (t) => `sorditud veeru järgi ${t.columnName} laskuvas järjestuses`,
+  resizerDescription: "Suuruse muutmise alustamiseks vajutage klahvi Enter",
+  select: "Vali",
+  selectAll: "Vali kõik",
+  sortable: "sorditav veerg"
+};
+var Bt = {};
+Bt = {
+  ascending: "nouseva",
+  ascendingSort: (t) => `lajiteltu sarakkeen ${t.columnName} mukaan nousevassa järjestyksessä`,
+  columnSize: (t) => `${t.value} pikseliä`,
+  descending: "laskeva",
+  descendingSort: (t) => `lajiteltu sarakkeen ${t.columnName} mukaan laskevassa järjestyksessä`,
+  resizerDescription: "Aloita koon muutos painamalla Enter-näppäintä",
+  select: "Valitse",
+  selectAll: "Valitse kaikki",
+  sortable: "lajiteltava sarake"
+};
+var Pt = {};
+Pt = {
+  ascending: "croissant",
+  ascendingSort: (t) => `trié en fonction de la colonne ${t.columnName} par ordre croissant`,
+  columnSize: (t) => `${t.value} pixels`,
+  descending: "décroissant",
+  descendingSort: (t) => `trié en fonction de la colonne ${t.columnName} par ordre décroissant`,
+  resizerDescription: "Appuyez sur Entrée pour commencer le redimensionnement.",
+  select: "Sélectionner",
+  selectAll: "Sélectionner tout",
+  sortable: "colonne triable"
+};
+var Kt = {};
+Kt = {
+  ascending: "עולה",
+  ascendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר עולה`,
+  columnSize: (t) => `${t.value} פיקסלים`,
+  descending: "יורד",
+  descendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר יורד`,
+  resizerDescription: "הקש Enter כדי לשנות את הגודל",
+  select: "בחר",
+  selectAll: "בחר הכול",
+  sortable: "עמודה שניתן למיין"
+};
+var Mt = {};
+Mt = {
+  ascending: "rastući",
+  ascendingSort: (t) => `razvrstano po stupcima ${t.columnName} rastućem redoslijedom`,
+  columnSize: (t) => `${t.value} piksela`,
+  descending: "padajući",
+  descendingSort: (t) => `razvrstano po stupcima ${t.columnName} padajućim redoslijedom`,
+  resizerDescription: "Pritisnite Enter da biste započeli promenu veličine",
+  select: "Odaberite",
+  selectAll: "Odaberite sve",
+  sortable: "stupac koji se može razvrstati"
+};
+var Tt = {};
+Tt = {
+  ascending: "növekvő",
+  ascendingSort: (t) => `rendezve a(z) ${t.columnName} oszlop szerint, növekvő sorrendben`,
+  columnSize: (t) => `${t.value} képpont`,
+  descending: "csökkenő",
+  descendingSort: (t) => `rendezve a(z) ${t.columnName} oszlop szerint, csökkenő sorrendben`,
+  resizerDescription: "Nyomja le az Enter billentyűt az átméretezés megkezdéséhez",
+  select: "Kijelölés",
+  selectAll: "Összes kijelölése",
+  sortable: "rendezendő oszlop"
+};
+var Nt = {};
+Nt = {
+  ascending: "crescente",
+  ascendingSort: (t) => `in ordine crescente in base alla colonna ${t.columnName}`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "decrescente",
+  descendingSort: (t) => `in ordine decrescente in base alla colonna ${t.columnName}`,
+  resizerDescription: "Premi Invio per iniziare a ridimensionare",
+  select: "Seleziona",
+  selectAll: "Seleziona tutto",
+  sortable: "colonna ordinabile"
+};
+var Ft = {};
+Ft = {
+  ascending: "昇順",
+  ascendingSort: (t) => `列 ${t.columnName} を昇順で並べ替え`,
+  columnSize: (t) => `${t.value} ピクセル`,
+  descending: "降順",
+  descendingSort: (t) => `列 ${t.columnName} を降順で並べ替え`,
+  resizerDescription: "Enter キーを押してサイズ変更を開始",
+  select: "選択",
+  selectAll: "すべて選択",
+  sortable: "並べ替え可能な列"
+};
+var It = {};
+It = {
+  ascending: "오름차순",
+  ascendingSort: (t) => `${t.columnName} 열을 기준으로 오름차순으로 정렬됨`,
+  columnSize: (t) => `${t.value} 픽셀`,
+  descending: "내림차순",
+  descendingSort: (t) => `${t.columnName} 열을 기준으로 내림차순으로 정렬됨`,
+  resizerDescription: "크기 조정을 시작하려면 Enter를 누르세요.",
+  select: "선택",
+  selectAll: "모두 선택",
+  sortable: "정렬 가능한 열"
+};
+var Wt = {};
+Wt = {
+  ascending: "didėjančia tvarka",
+  ascendingSort: (t) => `surikiuota pagal stulpelį ${t.columnName} didėjančia tvarka`,
+  columnSize: (t) => `${t.value} piks.`,
+  descending: "mažėjančia tvarka",
+  descendingSort: (t) => `surikiuota pagal stulpelį ${t.columnName} mažėjančia tvarka`,
+  resizerDescription: "Paspauskite „Enter“, kad pradėtumėte keisti dydį",
+  select: "Pasirinkti",
+  selectAll: "Pasirinkti viską",
+  sortable: "rikiuojamas stulpelis"
+};
+var Vt = {};
+Vt = {
+  ascending: "augošā secībā",
+  ascendingSort: (t) => `kārtots pēc kolonnas ${t.columnName} augošā secībā`,
+  columnSize: (t) => `${t.value} pikseļi`,
+  descending: "dilstošā secībā",
+  descendingSort: (t) => `kārtots pēc kolonnas ${t.columnName} dilstošā secībā`,
+  resizerDescription: "Nospiediet Enter, lai sāktu izmēru mainīšanu",
+  select: "Atlasīt",
+  selectAll: "Atlasīt visu",
+  sortable: "kārtojamā kolonna"
+};
+var Ht = {};
+Ht = {
+  ascending: "stigende",
+  ascendingSort: (t) => `sortert etter kolonne ${t.columnName} i stigende rekkefølge`,
+  columnSize: (t) => `${t.value} piksler`,
+  descending: "synkende",
+  descendingSort: (t) => `sortert etter kolonne ${t.columnName} i synkende rekkefølge`,
+  resizerDescription: "Trykk på Enter for å starte størrelsesendring",
+  select: "Velg",
+  selectAll: "Velg alle",
+  sortable: "kolonne som kan sorteres"
+};
+var jt = {};
+jt = {
+  ascending: "oplopend",
+  ascendingSort: (t) => `gesorteerd in oplopende volgorde in kolom ${t.columnName}`,
+  columnSize: (t) => `${t.value} pixels`,
+  descending: "aflopend",
+  descendingSort: (t) => `gesorteerd in aflopende volgorde in kolom ${t.columnName}`,
+  resizerDescription: "Druk op Enter om het formaat te wijzigen",
+  select: "Selecteren",
+  selectAll: "Alles selecteren",
+  sortable: "sorteerbare kolom"
+};
+var Ot = {};
+Ot = {
+  ascending: "rosnąco",
+  ascendingSort: (t) => `posortowano według kolumny ${t.columnName} w porządku rosnącym`,
+  columnSize: (t) => `Liczba pikseli: ${t.value}`,
+  descending: "malejąco",
+  descendingSort: (t) => `posortowano według kolumny ${t.columnName} w porządku malejącym`,
+  resizerDescription: "Naciśnij Enter, aby rozpocząć zmienianie rozmiaru",
+  select: "Zaznacz",
+  selectAll: "Zaznacz wszystko",
+  sortable: "kolumna z możliwością sortowania"
+};
+var Ut = {};
+Ut = {
+  ascending: "crescente",
+  ascendingSort: (t) => `classificado pela coluna ${t.columnName} em ordem crescente`,
+  columnSize: (t) => `${t.value} pixels`,
+  descending: "decrescente",
+  descendingSort: (t) => `classificado pela coluna ${t.columnName} em ordem decrescente`,
+  resizerDescription: "Pressione Enter para começar a redimensionar",
+  select: "Selecionar",
+  selectAll: "Selecionar tudo",
+  sortable: "coluna classificável"
+};
+var Lt = {};
+Lt = {
+  ascending: "ascendente",
+  ascendingSort: (t) => `Ordenar por coluna ${t.columnName} em ordem ascendente`,
+  columnSize: (t) => `${t.value} pixels`,
+  descending: "descendente",
+  descendingSort: (t) => `Ordenar por coluna ${t.columnName} em ordem descendente`,
+  resizerDescription: "Prima Enter para iniciar o redimensionamento",
+  select: "Selecionar",
+  selectAll: "Selecionar tudo",
+  sortable: "Coluna ordenável"
+};
+var Yt = {};
+Yt = {
+  ascending: "crescătoare",
+  ascendingSort: (t) => `sortate după coloana ${t.columnName} în ordine crescătoare`,
+  columnSize: (t) => `${t.value} pixeli`,
+  descending: "descrescătoare",
+  descendingSort: (t) => `sortate după coloana ${t.columnName} în ordine descrescătoare`,
+  resizerDescription: "Apăsați pe Enter pentru a începe redimensionarea",
+  select: "Selectare",
+  selectAll: "Selectare totală",
+  sortable: "coloană sortabilă"
+};
+var Xt = {};
+Xt = {
+  ascending: "возрастание",
+  ascendingSort: (t) => `сортировать столбец ${t.columnName} в порядке возрастания`,
+  columnSize: (t) => `${t.value} пикс.`,
+  descending: "убывание",
+  descendingSort: (t) => `сортировать столбец ${t.columnName} в порядке убывания`,
+  resizerDescription: "Нажмите клавишу Enter для начала изменения размеров",
+  select: "Выбрать",
+  selectAll: "Выбрать все",
+  sortable: "сортируемый столбец"
+};
+var qt = {};
+qt = {
+  ascending: "vzostupne",
+  ascendingSort: (t) => `zoradené zostupne podľa stĺpca ${t.columnName}`,
+  columnSize: (t) => `Počet pixelov: ${t.value}`,
+  descending: "zostupne",
+  descendingSort: (t) => `zoradené zostupne podľa stĺpca ${t.columnName}`,
+  resizerDescription: "Stlačením klávesu Enter začnete zmenu veľkosti",
+  select: "Vybrať",
+  selectAll: "Vybrať všetko",
+  sortable: "zoraditeľný stĺpec"
+};
+var Gt = {};
+Gt = {
+  ascending: "naraščajoče",
+  ascendingSort: (t) => `razvrščeno po stolpcu ${t.columnName} v naraščajočem vrstnem redu`,
+  columnSize: (t) => `${t.value} slikovnih pik`,
+  descending: "padajoče",
+  descendingSort: (t) => `razvrščeno po stolpcu ${t.columnName} v padajočem vrstnem redu`,
+  resizerDescription: "Pritisnite tipko Enter da začnete spreminjati velikost",
+  select: "Izberite",
+  selectAll: "Izberite vse",
+  sortable: "razvrstljivi stolpec"
+};
+var Zt = {};
+Zt = {
+  ascending: "rastući",
+  ascendingSort: (t) => `sortirano po kolonama ${t.columnName} rastućim redosledom`,
+  columnSize: (t) => `${t.value} piksela`,
+  descending: "padajući",
+  descendingSort: (t) => `sortirano po kolonama ${t.columnName} padajućim redosledom`,
+  resizerDescription: "Pritisnite Enter da biste započeli promenu veličine",
+  select: "Izaberite",
+  selectAll: "Izaberite sve",
+  sortable: "kolona koja se može sortirati"
+};
+var Jt = {};
+Jt = {
+  ascending: "stigande",
+  ascendingSort: (t) => `sorterat på kolumn ${t.columnName} i stigande ordning`,
+  columnSize: (t) => `${t.value} pixlar`,
+  descending: "fallande",
+  descendingSort: (t) => `sorterat på kolumn ${t.columnName} i fallande ordning`,
+  resizerDescription: "Tryck på Retur för att börja ändra storlek",
+  select: "Markera",
+  selectAll: "Markera allt",
+  sortable: "sorterbar kolumn"
+};
+var Qt = {};
+Qt = {
+  ascending: "artan sırada",
+  ascendingSort: (t) => `${t.columnName} sütuna göre artan düzende sırala`,
+  columnSize: (t) => `${t.value} piksel`,
+  descending: "azalan sırada",
+  descendingSort: (t) => `${t.columnName} sütuna göre azalan düzende sırala`,
+  resizerDescription: "Yeniden boyutlandırmak için Enter'a basın",
+  select: "Seç",
+  selectAll: "Tümünü Seç",
+  sortable: "Sıralanabilir sütun"
+};
+var _t = {};
+_t = {
+  ascending: "висхідний",
+  ascendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у висхідному порядку`,
+  columnSize: (t) => `${t.value} пікс.`,
+  descending: "низхідний",
+  descendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у низхідному порядку`,
+  resizerDescription: "Натисніть Enter, щоб почати зміну розміру",
+  select: "Вибрати",
+  selectAll: "Вибрати все",
+  sortable: "сортувальний стовпець"
+};
+var el = {};
+el = {
+  ascending: "升序",
+  ascendingSort: (t) => `按列 ${t.columnName} 升序排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "降序",
+  descendingSort: (t) => `按列 ${t.columnName} 降序排序`,
+  resizerDescription: "按“输入”键开始调整大小。",
+  select: "选择",
+  selectAll: "全选",
+  sortable: "可排序的列"
+};
+var tl = {};
+tl = {
+  ascending: "遞增",
+  ascendingSort: (t) => `已依據「${t.columnName}」欄遞增排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "遞減",
+  descendingSort: (t) => `已依據「${t.columnName}」欄遞減排序`,
+  resizerDescription: "按 Enter 鍵以開始調整大小",
+  select: "選取",
+  selectAll: "全選",
+  sortable: "可排序的欄"
+};
+var De = {};
+De = {
+  "ar-AE": Dt,
+  "bg-BG": Ct,
+  "cs-CZ": wt,
+  "da-DK": kt,
+  "de-DE": St,
+  "el-GR": Et,
+  "en-US": zt,
+  "es-ES": At,
+  "et-EE": Rt,
+  "fi-FI": Bt,
+  "fr-FR": Pt,
+  "he-IL": Kt,
+  "hr-HR": Mt,
+  "hu-HU": Tt,
+  "it-IT": Nt,
+  "ja-JP": Ft,
+  "ko-KR": It,
+  "lt-LT": Wt,
+  "lv-LV": Vt,
+  "nb-NO": Ht,
+  "nl-NL": jt,
+  "pl-PL": Ot,
+  "pt-BR": Ut,
+  "pt-PT": Lt,
+  "ro-RO": Yt,
+  "ru-RU": Xt,
+  "sk-SK": qt,
+  "sl-SI": Gt,
+  "sr-SP": Zt,
+  "sv-SE": Jt,
+  "tr-TR": Qt,
+  "uk-UA": _t,
+  "zh-CN": el,
+  "zh-TW": tl
+};
+class mn extends bt {
+  isCell(e) {
+    return e.type === "cell" || e.type === "rowheader" || e.type === "column";
+  }
+  getKeyBelow(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (l.type === "column") {
+      let n = te(W(l, this.collection));
+      if (n) return n.key;
+      let o = this.getFirstKey();
+      return o == null || !this.collection.getItem(o) ? null : super.getKeyForItemInRowByIndex(o, l.index);
+    }
+    return super.getKeyBelow(e);
+  }
+  getKeyAbove(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (l.type === "column") {
+      let r = l.parentKey != null ? this.collection.getItem(l.parentKey) : null;
+      return r && r.type === "column" ? r.key : null;
+    }
+    let n = super.getKeyAbove(e), o = n != null ? this.collection.getItem(n) : null;
+    return o && o.type !== "headerrow" ? n : this.isCell(l) ? this.collection.columns[l.index].key : this.collection.columns[0].key;
+  }
+  findNextColumnKey(e) {
+    let l = this.findNextKey(e.key, (o) => o.type === "column");
+    if (l != null) return l;
+    let n = this.collection.headerRows[e.level];
+    for (let o of W(n, this.collection))
+      if (o.type === "column") return o.key;
+    return null;
+  }
+  findPreviousColumnKey(e) {
+    let l = this.findPreviousKey(e.key, (r) => r.type === "column");
+    if (l != null) return l;
+    let n = this.collection.headerRows[e.level], o = [
+      ...W(n, this.collection)
+    ];
+    for (let r = o.length - 1; r >= 0; r--) {
+      let i = o[r];
+      if (i.type === "column") return i.key;
+    }
+    return null;
+  }
+  getKeyRightOf(e) {
+    let l = this.collection.getItem(e);
+    return l ? l.type === "column" ? this.direction === "rtl" ? this.findPreviousColumnKey(l) : this.findNextColumnKey(l) : super.getKeyRightOf(e) : null;
+  }
+  getKeyLeftOf(e) {
+    let l = this.collection.getItem(e);
+    return l ? l.type === "column" ? this.direction === "rtl" ? this.findNextColumnKey(l) : this.findPreviousColumnKey(l) : super.getKeyLeftOf(e) : null;
+  }
+  getKeyForSearch(e, l) {
+    if (!this.collator) return null;
+    let n = this.collection, o = l ?? this.getFirstKey();
+    if (o == null) return null;
+    let r = n.getItem(o);
+    var i;
+    r?.type === "cell" && (o = (i = r.parentKey) !== null && i !== void 0 ? i : null);
+    let u = !1;
+    for (; o != null; ) {
+      let a = n.getItem(o);
+      if (!a) return null;
+      if (a.textValue) {
+        let c = a.textValue.slice(0, e.length);
+        if (this.collator.compare(c, e) === 0) return a.key;
+      }
+      for (let c of W(a, this.collection)) {
+        let d = n.columns[c.index];
+        if (n.rowHeaderColumnKeys.has(d.key) && c.textValue) {
+          let s = c.textValue.slice(0, e.length);
+          if (this.collator.compare(s, e) === 0) {
+            let p = l != null ? n.getItem(l) : r;
+            return p?.type === "cell" ? c.key : a.key;
+          }
+        }
+      }
+      o = this.getKeyBelow(o), o == null && !u && (o = this.getFirstKey(), u = !0);
+    }
+    return null;
+  }
+}
+function gn(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function bn(t, e, l) {
+  let { keyboardDelegate: n, isVirtualized: o, layoutDelegate: r, layout: i } = t, u = ht({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: a } = pe(), c = e.selectionManager.disabledBehavior, d = T(() => n || new mn({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: c,
+    ref: l,
+    direction: a,
+    collator: u,
+    layoutDelegate: r,
+    layout: i
+  }), [
+    n,
+    e.collection,
+    e.disabledKeys,
+    c,
+    l,
+    a,
+    u,
+    r,
+    i
+  ]), s = Ae(t.id);
+  Ve.set(e, s);
+  let { gridProps: p } = dn({
+    ...t,
+    id: s,
+    keyboardDelegate: d
+  }, e, l);
+  o && (p["aria-rowcount"] = e.collection.size + e.collection.headerRows.length), Ee() && "expandedKeys" in e && (p.role = "treegrid");
+  let { column: f, direction: h } = e.sortDescriptor || {}, g = he(gn(De), "@react-aria/table"), y = T(() => {
+    var x, m;
+    let $ = (m = (x = e.collection.columns.find((b) => b.key === f)) === null || x === void 0 ? void 0 : x.textValue) !== null && m !== void 0 ? m : "";
+    return h && f ? g.format(`${h}Sort`, {
+      columnName: $
+    }) : void 0;
+  }, [
+    h,
+    f,
+    e.collection.columns
+  ]), v = Ie(y);
+  return ql(() => {
+    y && Xl(y, "assertive", 500);
+  }, [
+    y
+  ]), {
+    gridProps: H(p, v, {
+      // merge sort description with long press information
+      "aria-describedby": [
+        v["aria-describedby"],
+        p["aria-describedby"]
+      ].filter(Boolean).join(" ")
+    })
+  };
+}
+function vn(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function yn(t, e, l) {
+  var n, o;
+  let { node: r } = t, i = r.props.allowsSorting, { gridCellProps: u } = vt({
+    ...t,
+    focusMode: "child"
+  }, e, l), a = r.props.isSelectionCell && e.selectionManager.selectionMode === "single", { pressProps: c } = pt({
+    isDisabled: !i || a,
+    onPress() {
+      e.sort(r.key);
+    },
+    ref: l
+  }), { focusableProps: d } = Nl({}, l), s, p = ((n = e.sortDescriptor) === null || n === void 0 ? void 0 : n.column) === r.key, f = (o = e.sortDescriptor) === null || o === void 0 ? void 0 : o.direction;
+  r.props.allowsSorting && !_e() && (s = p ? f : "none");
+  let h = he(vn(De), "@react-aria/table"), g;
+  i && (g = `${h.format("sortable")}`, p && f && _e() && (g = `${g}, ${h.format(f)}`));
+  let y = Ie(g), v = e.collection.size === 0;
+  return oe(() => {
+    v && e.selectionManager.focusedKey === r.key && e.selectionManager.setFocusedKey(null);
+  }, [
+    v,
+    e.selectionManager,
+    r.key
+  ]), {
+    columnHeaderProps: {
+      ...H(
+        d,
+        u,
+        c,
+        y,
+        // If the table is empty, make all column headers untabbable
+        v ? {
+          tabIndex: -1
+        } : null
+      ),
+      role: "columnheader",
+      id: yt(e, r.key),
+      "aria-colspan": r.colSpan && r.colSpan > 1 ? r.colSpan : void 0,
+      "aria-sort": s
+    }
+  };
+}
+const lt = {
+  expand: {
+    ltr: "ArrowRight",
+    rtl: "ArrowLeft"
+  },
+  collapse: {
+    ltr: "ArrowLeft",
+    rtl: "ArrowRight"
+  }
+};
+function $n(t, e, l) {
+  let { node: n, isVirtualized: o } = t, { rowProps: r, ...i } = fn(t, e, l), { direction: u } = pe();
+  o && !(Ee() && "expandedKeys" in e) ? r["aria-rowindex"] = n.index + 1 + e.collection.headerRows.length : delete r["aria-rowindex"];
+  let a = {};
+  if (Ee() && "expandedKeys" in e) {
+    let b = e.keyMap.get(n.key);
+    if (b != null) {
+      var c, d, s, p, f, h;
+      let C = ((c = b.props) === null || c === void 0 ? void 0 : c.UNSTABLE_childItems) || ((s = b.props) === null || s === void 0 || (d = s.children) === null || d === void 0 ? void 0 : d.length) > e.userColumnCount;
+      var g, y, v, x;
+      a = {
+        onKeyDown: (k) => {
+          (k.key === lt.expand[u] && e.selectionManager.focusedKey === b.key && C && e.expandedKeys !== "all" && !e.expandedKeys.has(b.key) || k.key === lt.collapse[u] && e.selectionManager.focusedKey === b.key && C && (e.expandedKeys === "all" || e.expandedKeys.has(b.key))) && (e.toggleKey(b.key), k.stopPropagation());
+        },
+        "aria-expanded": C ? e.expandedKeys === "all" || e.expandedKeys.has(n.key) : void 0,
+        "aria-level": b.level,
+        "aria-posinset": ((g = b.indexOfType) !== null && g !== void 0 ? g : 0) + 1,
+        "aria-setsize": b.level > 1 ? ((v = (p = le((y = (f = e.keyMap.get(b.parentKey)) === null || f === void 0 ? void 0 : f.childNodes) !== null && y !== void 0 ? y : [])) === null || p === void 0 ? void 0 : p.indexOfType) !== null && v !== void 0 ? v : 0) + 1 : ((x = (h = le(e.collection.body.childNodes)) === null || h === void 0 ? void 0 : h.indexOfType) !== null && x !== void 0 ? x : 0) + 1
+      };
+    }
+  }
+  let m = jl(n.props), $ = i.hasAction ? m : {};
+  return {
+    rowProps: {
+      ...H(r, a, $),
+      "aria-labelledby": xt(e, n.key)
+    },
+    ...i
+  };
+}
+function xn(t, e, l) {
+  let { node: n, isVirtualized: o } = t, r = {
+    role: "row"
+  };
+  return o && !(Ee() && "expandedKeys" in e) && (r["aria-rowindex"] = n.index + 1), {
+    rowProps: r
+  };
+}
+function Dn(t, e, l) {
+  var n;
+  let { gridCellProps: o, isPressed: r } = vt(t, e, l), i = (n = t.node.column) === null || n === void 0 ? void 0 : n.key;
+  return i != null && e.collection.rowHeaderColumnKeys.has(i) && (o.role = "rowheader", o.id = $t(e, t.node.parentKey, i)), {
+    gridCellProps: o,
+    isPressed: r
+  };
+}
+function Cn(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function wn(t, e) {
+  let { key: l } = t;
+  const { checkboxProps: n } = hn(t, e);
+  return {
+    checkboxProps: {
+      ...n,
+      "aria-labelledby": `${n.id} ${xt(e, l)}`
+    }
+  };
+}
+function kn(t) {
+  let { isEmpty: e, isSelectAll: l, selectionMode: n } = t.selectionManager;
+  return {
+    checkboxProps: {
+      "aria-label": he(Cn(De), "@react-aria/table").format(n === "single" ? "select" : "selectAll"),
+      isSelected: l,
+      isDisabled: n !== "multiple" || t.collection.size === 0 || t.collection.rows.length === 1 && t.collection.rows[0].type === "loader",
+      isIndeterminate: !e && !l,
+      onChange: () => t.selectionManager.toggleSelectAll()
+    }
+  };
+}
+function Sn(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function En(t, e, l) {
+  let { column: n, triggerRef: o, isDisabled: r, onResizeStart: i, onResize: u, onResizeEnd: a, "aria-label": c } = t;
+  const d = he(Sn(De), "@react-aria/table");
+  let s = Ae(), p = e.resizingColumn === n.key, f = M(p), h = M(null), g = M(!1), y = e.tableState.isKeyboardNavigationDisabled, { direction: v } = pe(), { keyboardProps: x } = Fl({
+    onKeyDown: (S) => {
+      y ? (S.key === "Escape" || S.key === "Enter" || S.key === " " || S.key === "Tab") && (S.preventDefault(), b(n)) : (S.continuePropagation(), S.key === "Enter" && m(n));
+    }
+  }), m = ve((S) => {
+    f.current || (h.current = e.updateResizedColumns(S.key, e.getColumnWidth(S.key)), e.startResize(S.key), e.tableState.setKeyboardNavigationDisabled(!0), i?.(h.current)), f.current = !0;
+  }), $ = ve((S, B) => {
+    let L = e.updateResizedColumns(S.key, B);
+    u?.(L), h.current = L;
+  }), b = ve((S) => {
+    f.current && (h.current == null && (h.current = e.updateResizedColumns(S.key, e.getColumnWidth(S.key))), e.endResize(), e.tableState.setKeyboardNavigationDisabled(!1), a?.(h.current), f.current = !1, o?.current && !g.current && q(o.current)), h.current = null;
+  });
+  const C = M(0), { moveProps: k } = un({
+    onMoveStart() {
+      C.current = e.getColumnWidth(n.key), m(n);
+    },
+    onMove(S) {
+      let { deltaX: B, deltaY: L, pointerType: X } = S;
+      v === "rtl" && (B *= -1), X === "keyboard" && (L !== 0 && B === 0 && (B = L * -1), B *= 10), B !== 0 && (C.current += B, $(n, C.current));
+    },
+    onMoveEnd(S) {
+      let { pointerType: B } = S;
+      C.current = 0, (B === "mouse" || B === "touch" && g.current) && b(n);
+    }
+  });
+  let P = O((S) => {
+    var B;
+    y && ((B = k.onKeyDown) === null || B === void 0 || B.call(k, S));
+  }, [
+    y,
+    k
+  ]), K = Math.floor(e.getColumnMinWidth(n.key)), E = Math.floor(e.getColumnMaxWidth(n.key));
+  E === 1 / 0 && (E = Number.MAX_SAFE_INTEGER);
+  let N = Math.floor(e.getColumnWidth(n.key)), F = Wl();
+  F === "virtual" && typeof window < "u" && "ontouchstart" in window && (F = "touch");
+  let V = o?.current == null && (F === "keyboard" || F === "virtual") && !p ? d.format("resizerDescription") : void 0, z = Ie(V), R = {
+    "aria-label": c,
+    "aria-orientation": "horizontal",
+    "aria-labelledby": `${s} ${yt(e.tableState, n.key)}`,
+    "aria-valuetext": d.format("columnSize", {
+      value: N
+    }),
+    type: "range",
+    min: K,
+    max: E,
+    value: N,
+    ...z
+  };
+  const j = O(() => {
+    l.current && q(l.current);
+  }, [
+    l
+  ]);
+  let I = e.resizingColumn, Q = M(null);
+  oe(() => {
+    if (Q.current !== I && I != null && I === n.key) {
+      g.current = document.activeElement === l.current, m(n);
+      let S = setTimeout(() => j(), 0), B = setTimeout(j, 400);
+      return () => {
+        clearTimeout(S), clearTimeout(B);
+      };
+    }
+    Q.current = I;
+  }, [
+    I,
+    n,
+    j,
+    l,
+    m
+  ]);
+  let ge = (S) => {
+    let B = e.getColumnWidth(n.key), L = parseFloat(S.target.value);
+    L > B ? L = B + 10 : L = B - 10, $(n, L);
+  }, { pressProps: Ce } = pt({
+    preventFocusOnPress: !0,
+    onPressStart: (S) => {
+      if (!(S.ctrlKey || S.altKey || S.metaKey || S.shiftKey || S.pointerType === "keyboard")) {
+        if (S.pointerType === "virtual" && e.resizingColumn != null) {
+          b(n);
+          return;
+        }
+        j(), S.pointerType !== "virtual" && m(n);
+      }
+    },
+    onPress: (S) => {
+      (S.pointerType === "touch" && g.current || S.pointerType === "mouse") && e.resizingColumn != null && b(n);
+    }
+  }), { visuallyHiddenProps: we } = Re();
+  return {
+    resizerProps: H(x, {
+      ...k,
+      onKeyDown: P
+    }, Ce, {
+      style: {
+        touchAction: "none"
+      }
+    }),
+    inputProps: H(we, {
+      id: s,
+      onBlur: () => {
+        b(n);
+      },
+      onChange: ge,
+      disabled: r
+    }, R),
+    isResizing: p
+  };
+}
+function ll() {
+  return cn();
+}
+function zn(t) {
+  return t != null && (!isNaN(t) || String(t).match(/^(\d+)(?=%$)/) !== null);
+}
+function An(t) {
+  if (!t || typeof t == "number") return 1;
+  let e = t.match(/^(.+)(?=fr$)/);
+  return e ? parseFloat(e[0]) : (process.env.NODE_ENV !== "production" && console.warn(`width: ${t} is not a supported format, width should be a number (ex. 150), percentage (ex. '50%') or fr unit (ex. '2fr')`, "defaulting to '1fr'"), 1);
+}
+function He(t, e) {
+  if (typeof t == "string") {
+    let l = t.match(/^(\d+)(?=%$)/);
+    if (!l) throw new Error("Only percentages or numbers are supported for static column widths");
+    return e * (parseFloat(l[0]) / 100);
+  }
+  return t;
+}
+function nl(t, e) {
+  return t != null ? He(t, e) : Number.MAX_SAFE_INTEGER;
+}
+function ol(t, e) {
+  return t != null ? He(t, e) : 0;
+}
+function Rn(t, e, l, n, o) {
+  let r = !1, i = e.map((u, a) => {
+    var c, d, s, p;
+    let f = l.get(u.key) != null ? (c = l.get(u.key)) !== null && c !== void 0 ? c : "1fr" : (p = (s = (d = u.width) !== null && d !== void 0 ? d : u.defaultWidth) !== null && s !== void 0 ? s : n?.(a)) !== null && p !== void 0 ? p : "1fr", h = !1, g = 0, y = 0, v = 0;
+    zn(f) ? (g = He(f, t), h = !0) : (y = An(f), y <= 0 && (h = !0));
+    var x, m;
+    let $ = ol((m = (x = u.minWidth) !== null && x !== void 0 ? x : o?.(a)) !== null && m !== void 0 ? m : 0, t), b = nl(u.maxWidth, t), C = Math.max($, Math.min(g, b));
+    return h ? v = C : g > C && (h = !0, v = C), h || (r = !0), {
+      frozen: h,
+      baseSize: g,
+      hypotheticalMainSize: C,
+      min: $,
+      max: b,
+      flex: y,
+      targetMainSize: v,
+      violation: 0
+    };
+  });
+  for (; r; ) {
+    let u = 0, a = 0;
+    i.forEach((s) => {
+      s.frozen ? u += s.targetMainSize : (u += s.baseSize, a += s.flex);
+    });
+    let c = t - u;
+    c > 0 && i.forEach((s) => {
+      if (!s.frozen) {
+        let p = s.flex / a;
+        s.targetMainSize = s.baseSize + p * c;
+      }
+    });
+    let d = 0;
+    i.forEach((s) => {
+      if (s.violation = 0, !s.frozen) {
+        let { min: p, max: f, targetMainSize: h } = s;
+        s.targetMainSize = Math.max(p, Math.min(h, f)), s.violation = s.targetMainSize - h, d += s.violation;
+      }
+    }), r = !1, i.forEach((s) => {
+      d === 0 || Math.sign(d) === Math.sign(s.violation) ? s.frozen = !0 : s.frozen || (r = !0);
+    });
+  }
+  return Bn(i);
+}
+function Bn(t) {
+  let e = 0, l = 0, n = [];
+  return t.forEach(function(o) {
+    let r = o.targetMainSize, i = Math.round(r + e) - l;
+    e += r, l += i, n.push(i);
+  }), n;
+}
+class Pn {
+  /** Takes an array of columns and splits it into 2 maps of columns with controlled and columns with uncontrolled widths. */
+  splitColumnsIntoControlledAndUncontrolled(e) {
+    return e.reduce((l, n) => (n.props.width != null ? l[0].set(n.key, n) : l[1].set(n.key, n), l), [
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map()
+    ]);
+  }
+  /** Takes uncontrolled and controlled widths and joins them into a single Map. */
+  recombineColumns(e, l, n, o) {
+    return new Map(e.map((r) => n.has(r.key) ? [
+      r.key,
+      l.get(r.key)
+    ] : [
+      r.key,
+      o.get(r.key).props.width
+    ]));
+  }
+  /** Used to make an initial Map of the uncontrolled widths based on default widths. */
+  getInitialUncontrolledWidths(e) {
+    return new Map(Array.from(e).map(([l, n]) => {
+      var o, r, i, u;
+      return [
+        l,
+        (u = (i = n.props.defaultWidth) !== null && i !== void 0 ? i : (o = (r = this).getDefaultWidth) === null || o === void 0 ? void 0 : o.call(r, n)) !== null && u !== void 0 ? u : "1fr"
+      ];
+    }));
+  }
+  getColumnWidth(e) {
+    var l;
+    return (l = this.columnWidths.get(e)) !== null && l !== void 0 ? l : 0;
+  }
+  getColumnMinWidth(e) {
+    var l;
+    return (l = this.columnMinWidths.get(e)) !== null && l !== void 0 ? l : 0;
+  }
+  getColumnMaxWidth(e) {
+    var l;
+    return (l = this.columnMaxWidths.get(e)) !== null && l !== void 0 ? l : 0;
+  }
+  resizeColumnWidth(e, l, n, o) {
+    let r = this.columnWidths, i = !0, u = /* @__PURE__ */ new Map();
+    return o = Math.max(this.getColumnMinWidth(n), Math.min(this.getColumnMaxWidth(n), Math.floor(o))), e.columns.forEach((a) => {
+      var c, d;
+      a.key === n ? (u.set(a.key, o), i = !1) : i ? u.set(a.key, (c = r.get(a.key)) !== null && c !== void 0 ? c : 0) : u.set(a.key, (d = a.props.width) !== null && d !== void 0 ? d : l.get(a.key));
+    }), u;
+  }
+  buildColumnWidths(e, l, n) {
+    return this.columnWidths = /* @__PURE__ */ new Map(), this.columnMinWidths = /* @__PURE__ */ new Map(), this.columnMaxWidths = /* @__PURE__ */ new Map(), Rn(e, l.columns.map((r) => ({
+      ...r.props,
+      key: r.key
+    })), n, (r) => this.getDefaultWidth(l.columns[r]), (r) => this.getDefaultMinWidth(l.columns[r])).forEach((r, i) => {
+      let u = l.columns[i].key, a = l.columns[i];
+      this.columnWidths.set(u, r);
+      var c;
+      this.columnMinWidths.set(u, ol((c = a.props.minWidth) !== null && c !== void 0 ? c : this.getDefaultMinWidth(a), e)), this.columnMaxWidths.set(u, nl(a.props.maxWidth, e));
+    }), this.columnWidths;
+  }
+  constructor(e) {
+    this.columnWidths = /* @__PURE__ */ new Map(), this.columnMinWidths = /* @__PURE__ */ new Map(), this.columnMaxWidths = /* @__PURE__ */ new Map();
+    var l;
+    this.getDefaultWidth = (l = e?.getDefaultWidth) !== null && l !== void 0 ? l : () => "1fr";
+    var n;
+    this.getDefaultMinWidth = (n = e?.getDefaultMinWidth) !== null && n !== void 0 ? n : () => 75;
+  }
+}
+function Kn(t, e) {
+  let { getDefaultWidth: l, getDefaultMinWidth: n, tableWidth: o = 0 } = t, [r, i] = G(null), u = T(() => new Pn({
+    getDefaultWidth: l,
+    getDefaultMinWidth: n
+  }), [
+    l,
+    n
+  ]), [a, c] = T(() => u.splitColumnsIntoControlledAndUncontrolled(e.collection.columns), [
+    e.collection.columns,
+    u
+  ]), [d, s] = G(() => u.getInitialUncontrolledWidths(c)), [p, f] = G(e.collection.columns);
+  if (e.collection.columns !== p) {
+    if (e.collection.columns.length !== p.length || e.collection.columns.some((m, $) => m.key !== p[$].key)) {
+      let m = u.getInitialUncontrolledWidths(c);
+      s(m);
+    }
+    f(e.collection.columns);
+  }
+  let h = T(() => u.recombineColumns(e.collection.columns, d, c, a), [
+    e.collection.columns,
+    d,
+    c,
+    a,
+    u
+  ]), g = O((m) => {
+    i(m);
+  }, [
+    i
+  ]), y = O((m, $) => {
+    let b = u.resizeColumnWidth(e.collection, d, m, $), C = new Map(Array.from(c).map(([k]) => [
+      k,
+      b.get(k)
+    ]));
+    return C.set(m, $), s(C), b;
+  }, [
+    c,
+    s,
+    u,
+    e.collection,
+    d
+  ]), v = O(() => {
+    i(null);
+  }, [
+    i
+  ]), x = T(() => u.buildColumnWidths(o, e.collection, h), [
+    o,
+    e.collection,
+    h,
+    u
+  ]);
+  return T(() => ({
+    resizingColumn: r,
+    updateResizedColumns: y,
+    startResize: g,
+    endResize: v,
+    getColumnWidth: (m) => u.getColumnWidth(m),
+    getColumnMinWidth: (m) => u.getColumnMinWidth(m),
+    getColumnMaxWidth: (m) => u.getColumnMaxWidth(m),
+    tableState: e,
+    columnWidths: x
+  }), [
+    u,
+    x,
+    r,
+    y,
+    g,
+    v,
+    e
+  ]);
+}
+function Mn(t) {
+  let { collection: e, focusMode: l } = t, n = t.UNSAFE_selectionState || dt(t), o = T(() => t.disabledKeys ? new Set(t.disabledKeys) : /* @__PURE__ */ new Set(), [
+    t.disabledKeys
+  ]), r = n.setFocusedKey;
+  n.setFocusedKey = (a, c) => {
+    if (l === "cell" && a != null) {
+      let h = e.getItem(a);
+      if (h?.type === "item") {
+        var d, s;
+        let g = W(h, e);
+        var p, f;
+        c === "last" ? a = (p = (d = le(g)) === null || d === void 0 ? void 0 : d.key) !== null && p !== void 0 ? p : null : a = (f = (s = te(g)) === null || s === void 0 ? void 0 : s.key) !== null && f !== void 0 ? f : null;
+      }
+    }
+    r(a, c);
+  };
+  let i = T(() => new vl(e, n), [
+    e,
+    n
+  ]);
+  const u = M(null);
+  return oe(() => {
+    if (n.focusedKey != null && u.current && !e.getItem(n.focusedKey)) {
+      const a = u.current.getItem(n.focusedKey), c = a?.parentKey != null && (a.type === "cell" || a.type === "rowheader" || a.type === "column") ? u.current.getItem(a.parentKey) : a;
+      if (!c) {
+        n.setFocusedKey(null);
+        return;
+      }
+      const d = u.current.rows, s = e.rows, p = d.length - s.length;
+      let f = Math.min(p > 1 ? Math.max(c.index - p + 1, 0) : c.index, s.length - 1), h = null;
+      for (; f >= 0; ) {
+        if (!i.isDisabled(s[f].key) && s[f].type !== "headerrow") {
+          h = s[f];
+          break;
+        }
+        f < s.length - 1 ? f++ : (f > c.index && (f = c.index), f--);
+      }
+      if (h) {
+        const g = h.hasChildNodes ? [
+          ...W(h, e)
+        ] : [], y = h.hasChildNodes && c !== a && a && a.index < g.length ? g[a.index].key : h.key;
+        n.setFocusedKey(y);
+      } else n.setFocusedKey(null);
+    }
+    u.current = e;
+  }, [
+    e,
+    i,
+    n,
+    n.focusedKey
+  ]), {
+    collection: e,
+    disabledKeys: o,
+    isKeyboardNavigationDisabled: !1,
+    selectionManager: i
+  };
+}
+class Tn {
+  *[Symbol.iterator]() {
+    yield* [
+      ...this.rows
+    ];
+  }
+  get size() {
+    return [
+      ...this.rows
+    ].length;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return l && (n = l.prevKey) !== null && n !== void 0 ? n : null;
+  }
+  getKeyAfter(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return l && (n = l.nextKey) !== null && n !== void 0 ? n : null;
+  }
+  getFirstKey() {
+    var e;
+    return (e = [
+      ...this.rows
+    ][0]) === null || e === void 0 ? void 0 : e.key;
+  }
+  getLastKey() {
+    var e;
+    let l = [
+      ...this.rows
+    ];
+    return (e = l[l.length - 1]) === null || e === void 0 ? void 0 : e.key;
+  }
+  getItem(e) {
+    var l;
+    return (l = this.keyMap.get(e)) !== null && l !== void 0 ? l : null;
+  }
+  at(e) {
+    const l = [
+      ...this.getKeys()
+    ];
+    return this.getItem(l[e]);
+  }
+  getChildren(e) {
+    let l = this.keyMap.get(e);
+    return l?.childNodes || [];
+  }
+  constructor(e) {
+    this.keyMap = /* @__PURE__ */ new Map(), this.keyMap = /* @__PURE__ */ new Map(), this.columnCount = e?.columnCount, this.rows = [];
+    let l = (s) => {
+      let p = this.keyMap.get(s.key);
+      e.visitNode && (s = e.visitNode(s)), this.keyMap.set(s.key, s);
+      let f = /* @__PURE__ */ new Set(), h = null, g = !1;
+      if (s.type === "item") {
+        var y;
+        for (let b of s.childNodes) if (((y = b.props) === null || y === void 0 ? void 0 : y.colSpan) !== void 0) {
+          g = !0;
+          break;
+        }
+      }
+      for (let b of s.childNodes) {
+        if (b.type === "cell" && g) {
+          var v, x;
+          b.colspan = (v = b.props) === null || v === void 0 ? void 0 : v.colSpan, b.colSpan = (x = b.props) === null || x === void 0 ? void 0 : x.colSpan;
+          var m, $;
+          b.colIndex = h ? ((m = h.colIndex) !== null && m !== void 0 ? m : h.index) + (($ = h.colSpan) !== null && $ !== void 0 ? $ : 1) : b.index;
+        }
+        b.type === "cell" && b.parentKey == null && (b.parentKey = s.key), f.add(b.key), h ? (h.nextKey = b.key, b.prevKey = h.key) : b.prevKey = null, l(b), h = b;
+      }
+      if (h && (h.nextKey = null), p)
+        for (let b of p.childNodes) f.has(b.key) || n(b);
+    }, n = (s) => {
+      this.keyMap.delete(s.key);
+      for (let p of s.childNodes) this.keyMap.get(p.key) === p && n(p);
+    }, o = null;
+    for (let [s, p] of e.items.entries()) {
+      var r, i, u, a, c, d;
+      let f = {
+        ...p,
+        level: (r = p.level) !== null && r !== void 0 ? r : 0,
+        key: (i = p.key) !== null && i !== void 0 ? i : "row-" + s,
+        type: (u = p.type) !== null && u !== void 0 ? u : "row",
+        value: (a = p.value) !== null && a !== void 0 ? a : null,
+        hasChildNodes: !0,
+        childNodes: [
+          ...p.childNodes
+        ],
+        rendered: p.rendered,
+        textValue: (c = p.textValue) !== null && c !== void 0 ? c : "",
+        index: (d = p.index) !== null && d !== void 0 ? d : s
+      };
+      o ? (o.nextKey = f.key, f.prevKey = o.key) : f.prevKey = null, this.rows.push(f), l(f), o = f;
+    }
+    o && (o.nextKey = null);
+  }
+}
+const rl = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+let Ne = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+for (; rl === Ne; ) Ne = "row-header-column-" + Math.random().toString(36).slice(2);
+function il(t, e) {
+  if (e.length === 0) return [];
+  let l = [], n = /* @__PURE__ */ new Map();
+  for (let d of e) {
+    let s = d.parentKey, p = [
+      d
+    ];
+    for (; s; ) {
+      let f = t.get(s);
+      if (!f) break;
+      if (n.has(f)) {
+        var o, r;
+        (r = (o = f).colSpan) !== null && r !== void 0 || (o.colSpan = 0), f.colSpan++, f.colspan = f.colSpan;
+        let { column: h, index: g } = n.get(f);
+        if (g > p.length) break;
+        for (let y = g; y < p.length; y++) h.splice(y, 0, null);
+        for (let y = p.length; y < h.length; y++)
+          h[y] && n.has(h[y]) && (n.get(h[y]).index = y);
+      } else
+        f.colSpan = 1, f.colspan = 1, p.push(f), n.set(f, {
+          column: p,
+          index: p.length - 1
+        });
+      s = f.parentKey;
+    }
+    l.push(p), d.index = l.length - 1;
+  }
+  let i = Math.max(...l.map((d) => d.length)), u = Array(i).fill(0).map(() => []), a = 0;
+  for (let d of l) {
+    let s = i - 1;
+    for (let p of d) {
+      if (p) {
+        let f = u[s], h = f.reduce((g, y) => {
+          var v;
+          return g + ((v = y.colSpan) !== null && v !== void 0 ? v : 1);
+        }, 0);
+        if (h < a) {
+          let g = {
+            type: "placeholder",
+            key: "placeholder-" + p.key,
+            colspan: a - h,
+            colSpan: a - h,
+            index: h,
+            value: null,
+            rendered: null,
+            level: s,
+            hasChildNodes: !1,
+            childNodes: [],
+            textValue: ""
+          };
+          f.length > 0 && (f[f.length - 1].nextKey = g.key, g.prevKey = f[f.length - 1].key), f.push(g);
+        }
+        f.length > 0 && (f[f.length - 1].nextKey = p.key, p.prevKey = f[f.length - 1].key), p.level = s, p.colIndex = a, f.push(p);
+      }
+      s--;
+    }
+    a++;
+  }
+  let c = 0;
+  for (let d of u) {
+    let s = d.reduce((p, f) => {
+      var h;
+      return p + ((h = f.colSpan) !== null && h !== void 0 ? h : 1);
+    }, 0);
+    if (s < e.length) {
+      let p = {
+        type: "placeholder",
+        key: "placeholder-" + d[d.length - 1].key,
+        colSpan: e.length - s,
+        colspan: e.length - s,
+        index: s,
+        value: null,
+        rendered: null,
+        level: c,
+        hasChildNodes: !1,
+        childNodes: [],
+        textValue: "",
+        prevKey: d[d.length - 1].key
+      };
+      d.push(p);
+    }
+    c++;
+  }
+  return u.map((d, s) => ({
+    type: "headerrow",
+    key: "headerrow-" + s,
+    index: s,
+    value: null,
+    rendered: null,
+    level: 0,
+    hasChildNodes: !0,
+    childNodes: d,
+    textValue: ""
+  }));
+}
+class Nn extends Tn {
+  *[Symbol.iterator]() {
+    yield* this.body.childNodes;
+  }
+  get size() {
+    return this._size;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return (n = l?.prevKey) !== null && n !== void 0 ? n : null;
+  }
+  getKeyAfter(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return (n = l?.nextKey) !== null && n !== void 0 ? n : null;
+  }
+  getFirstKey() {
+    var e, l;
+    return (l = (e = te(this.body.childNodes)) === null || e === void 0 ? void 0 : e.key) !== null && l !== void 0 ? l : null;
+  }
+  getLastKey() {
+    var e, l;
+    return (l = (e = le(this.body.childNodes)) === null || e === void 0 ? void 0 : e.key) !== null && l !== void 0 ? l : null;
+  }
+  getItem(e) {
+    var l;
+    return (l = this.keyMap.get(e)) !== null && l !== void 0 ? l : null;
+  }
+  at(e) {
+    const l = [
+      ...this.getKeys()
+    ];
+    return this.getItem(l[e]);
+  }
+  getChildren(e) {
+    return e === this.body.key ? this.body.childNodes : super.getChildren(e);
+  }
+  getTextValue(e) {
+    let l = this.getItem(e);
+    if (!l) return "";
+    if (l.textValue) return l.textValue;
+    let n = this.rowHeaderColumnKeys;
+    if (n) {
+      let o = [];
+      for (let r of l.childNodes) {
+        let i = this.columns[r.index];
+        if (n.has(i.key) && r.textValue && o.push(r.textValue), o.length === n.size) break;
+      }
+      return o.join(" ");
+    }
+    return "";
+  }
+  constructor(e, l, n) {
+    let o = /* @__PURE__ */ new Set(), r = null, i = [];
+    if (n?.showSelectionCheckboxes) {
+      let s = {
+        type: "column",
+        key: rl,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: n?.showDragButtons ? 1 : 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isSelectionCell: !0
+        }
+      };
+      i.unshift(s);
+    }
+    if (n?.showDragButtons) {
+      let s = {
+        type: "column",
+        key: Ne,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isDragButtonCell: !0
+        }
+      };
+      i.unshift(s);
+    }
+    let u = [], a = /* @__PURE__ */ new Map(), c = (s) => {
+      switch (s.type) {
+        case "body":
+          r = s;
+          break;
+        case "column":
+          a.set(s.key, s), s.hasChildNodes || (i.push(s), s.props.isRowHeader && o.add(s.key));
+          break;
+        case "item":
+          u.push(s);
+          return;
+      }
+      for (let p of s.childNodes) c(p);
+    };
+    for (let s of e) c(s);
+    let d = il(a, i);
+    if (d.forEach((s, p) => u.splice(p, 0, s)), super({
+      columnCount: i.length,
+      items: u,
+      visitNode: (s) => (s.column = i[s.index], s)
+    }), this._size = 0, this.columns = i, this.rowHeaderColumnKeys = o, this.body = r, this.headerRows = d, this._size = [
+      ...r.childNodes
+    ].length, this.rowHeaderColumnKeys.size === 0) {
+      let s = this.columns.find((p) => {
+        var f, h;
+        return !(!((f = p.props) === null || f === void 0) && f.isDragButtonCell) && !(!((h = p.props) === null || h === void 0) && h.isSelectionCell);
+      });
+      s && this.rowHeaderColumnKeys.add(s.key);
+    }
+  }
+}
+const Fn = {
+  ascending: "descending",
+  descending: "ascending"
+};
+function In(t) {
+  let [e, l] = G(!1), { selectionMode: n = "none", showSelectionCheckboxes: o, showDragButtons: r } = t, i = T(() => ({
+    showSelectionCheckboxes: o && n !== "none",
+    showDragButtons: r,
+    selectionMode: n,
+    columns: []
+  }), [
+    t.children,
+    o,
+    n,
+    r
+  ]), u = yl(t, O((s) => new Nn(s, null, i), [
+    i
+  ]), i), { disabledKeys: a, selectionManager: c } = Mn({
+    ...t,
+    collection: u,
+    disabledBehavior: t.disabledBehavior || "selection"
+  });
+  var d;
+  return {
+    collection: u,
+    disabledKeys: a,
+    selectionManager: c,
+    showSelectionCheckboxes: t.showSelectionCheckboxes || !1,
+    sortDescriptor: (d = t.sortDescriptor) !== null && d !== void 0 ? d : null,
+    isKeyboardNavigationDisabled: u.size === 0 || e,
+    setKeyboardNavigationDisabled: l,
+    sort(s, p) {
+      var f, h;
+      (h = t.onSortChange) === null || h === void 0 || h.call(t, {
+        column: s,
+        direction: p ?? (((f = t.sortDescriptor) === null || f === void 0 ? void 0 : f.column) === s ? Fn[t.sortDescriptor.direction] : "ascending")
+      });
+    }
+  };
+}
+function Wn(t) {
+  return t && t.__esModule ? t.default : t;
+}
+class Vn extends Dl {
+  addNode(e) {
+    super.addNode(e), this.columnsDirty || (this.columnsDirty = e.type === "column"), e.type === "tableheader" && (this.head = e), e.type === "tablebody" && (this.body = e);
+  }
+  commit(e, l, n = !1) {
+    this.updateColumns(n), this.rows = [];
+    for (let i of this.getChildren(this.body.key)) {
+      let u = i.lastChildKey;
+      if (u != null) {
+        let a = this.getItem(u);
+        var o, r;
+        let c = ((o = a.colIndex) !== null && o !== void 0 ? o : a.index) + ((r = a.colSpan) !== null && r !== void 0 ? r : 1);
+        if (c !== this.columns.length && !n) throw new Error(`Cell count must match column count. Found ${c} cells and ${this.columns.length} columns.`);
+      }
+      this.rows.push(i);
+    }
+    super.commit(e, l, n);
+  }
+  updateColumns(e) {
+    if (!this.columnsDirty) return;
+    this.rowHeaderColumnKeys = /* @__PURE__ */ new Set(), this.columns = [];
+    let l = /* @__PURE__ */ new Map(), n = (o) => {
+      switch (o.type) {
+        case "column":
+          l.set(o.key, o), o.hasChildNodes || (o.index = this.columns.length, this.columns.push(o), o.props.isRowHeader && this.rowHeaderColumnKeys.add(o.key));
+          break;
+      }
+      for (let r of this.getChildren(o.key)) n(r);
+    };
+    for (let o of this.getChildren(this.head.key)) n(o);
+    if (this.headerRows = il(l, this.columns), this.columnsDirty = !1, this.rowHeaderColumnKeys.size === 0 && this.columns.length > 0 && !e) throw new Error("A table must have at least one Column with the isRowHeader prop set to true");
+  }
+  get columnCount() {
+    return this.columns.length;
+  }
+  *[Symbol.iterator]() {
+    this.head.key !== -1 && (yield this.head, yield this.body);
+  }
+  getFirstKey() {
+    return this.body.firstChildKey;
+  }
+  getLastKey() {
+    return this.body.lastChildKey;
+  }
+  getKeyAfter(e) {
+    let l = this.getItem(e);
+    var n;
+    return l?.type === "column" ? (n = l.nextKey) !== null && n !== void 0 ? n : null : super.getKeyAfter(e);
+  }
+  getKeyBefore(e) {
+    var l;
+    let n = this.getItem(e);
+    var o;
+    if (n?.type === "column") return (o = n.prevKey) !== null && o !== void 0 ? o : null;
+    let r = super.getKeyBefore(e);
+    return r != null && ((l = this.getItem(r)) === null || l === void 0 ? void 0 : l.type) === "tablebody" ? null : r;
+  }
+  getChildren(e) {
+    if (!this.getItem(e)) {
+      for (let l of this.headerRows)
+        if (l.key === e) return l.childNodes;
+    }
+    return super.getChildren(e);
+  }
+  clone() {
+    let e = super.clone();
+    return e.headerRows = this.headerRows, e.columns = this.columns, e.rowHeaderColumnKeys = this.rowHeaderColumnKeys, e.head = this.head, e.body = this.body, e;
+  }
+  getTextValue(e) {
+    let l = this.getItem(e);
+    if (!l) return "";
+    if (l.textValue) return l.textValue;
+    let n = this.rowHeaderColumnKeys, o = [];
+    for (let r of this.getChildren(e)) {
+      let i = this.columns[r.index];
+      if (n.has(i.key) && r.textValue && o.push(r.textValue), o.length === n.size) break;
+    }
+    return o.join(" ");
+  }
+  constructor(...e) {
+    super(...e), this.headerRows = [], this.columns = [], this.rows = [], this.rowHeaderColumnKeys = /* @__PURE__ */ new Set(), this.head = new Ze("tableheader", -1), this.body = new Ze("tablebody", -2), this.columnsDirty = !0;
+  }
+}
+const je = /* @__PURE__ */ ie(null), Hn = /* @__PURE__ */ Y(function(e, l) {
+  let n = ae(l), o = M(null), r = M(null), [i, u] = G(0);
+  Qe(() => {
+    let c = o.current;
+    for (; c && c !== n.current && !Pl(c); ) c = c.parentElement;
+    r.current = c;
+  }, [
+    n
+  ]), Bl({
+    ref: r,
+    box: "border-box",
+    onResize() {
+      var c, d;
+      u((d = (c = r.current) === null || c === void 0 ? void 0 : c.clientWidth) !== null && d !== void 0 ? d : 0);
+    }
+  }), Qe(() => {
+    var c, d;
+    u((d = (c = r.current) === null || c === void 0 ? void 0 : c.clientWidth) !== null && d !== void 0 ? d : 0);
+  }, []);
+  let a = T(() => ({
+    tableRef: o,
+    scrollRef: r,
+    tableWidth: i,
+    useTableColumnResizeState: Kn,
+    onResizeStart: e.onResizeStart,
+    onResize: e.onResize,
+    onResizeEnd: e.onResizeEnd
+  }), [
+    o,
+    i,
+    e.onResizeStart,
+    e.onResize,
+    e.onResizeEnd
+  ]);
+  return /* @__PURE__ */ w.createElement("div", {
+    ...J(e, {
+      global: !0
+    }),
+    ref: n,
+    className: e.className || "react-aria-ResizableTableContainer",
+    style: e.style,
+    onScroll: e.onScroll
+  }, /* @__PURE__ */ w.createElement(je.Provider, {
+    value: a
+  }, e.children));
+}), jn = /* @__PURE__ */ ie(null), _ = /* @__PURE__ */ ie(null), Oe = /* @__PURE__ */ ie(null), On = /* @__PURE__ */ Y(function(e, l) {
+  var n;
+  [e, l] = wl(e, l, jn);
+  let o = dt(e), { selectionBehavior: r, selectionMode: i, disallowEmptySelection: u } = o, a = !!(!((n = e.dragAndDropHooks) === null || n === void 0) && n.useDraggableCollectionState), c = T(() => ({
+    selectionBehavior: i === "none" ? null : r,
+    selectionMode: i,
+    disallowEmptySelection: u,
+    allowsDragging: a
+  }), [
+    r,
+    i,
+    u,
+    a
+  ]), d = /* @__PURE__ */ w.createElement(al.Provider, {
+    value: c
+  }, /* @__PURE__ */ w.createElement($e, e));
+  return /* @__PURE__ */ w.createElement($l, {
+    content: d,
+    createCollection: () => new Vn()
+  }, (s) => /* @__PURE__ */ w.createElement(Un, {
+    props: e,
+    forwardedRef: l,
+    selectionState: o,
+    collection: s
+  }));
+});
+function Un({ props: t, forwardedRef: e, selectionState: l, collection: n }) {
+  let o = A(je);
+  e = ae(T(() => kl(e, o?.tableRef), [
+    e,
+    o?.tableRef
+  ]));
+  let r = In({
+    ...t,
+    collection: n,
+    children: void 0,
+    UNSAFE_selectionState: l
+  }), { isVirtualized: i, layoutDelegate: u, dropTargetDelegate: a, CollectionRoot: c } = A(Z), { dragAndDropHooks: d } = t, { gridProps: s } = bn({
+    ...t,
+    layoutDelegate: u,
+    isVirtualized: i
+  }, r, e), p = r.selectionManager, f = !!d?.useDraggableCollectionState, h = !!d?.useDroppableCollectionState, g = M(f), y = M(h);
+  oe(() => {
+    process.env.NODE_ENV !== "production" && (g.current !== f && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), y.current !== h && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."));
+  }, [
+    f,
+    h
+  ]);
+  let v, x, m, $ = !1, b = null, C = M(null);
+  if (f && d) {
+    v = d.useDraggableCollectionState({
+      collection: n,
+      selectionManager: p,
+      preview: d.renderDragPreview ? C : void 0
+    }), d.useDraggableCollection({}, v, e);
+    let I = d.DragPreview;
+    b = d.renderDragPreview ? /* @__PURE__ */ w.createElement(I, {
+      ref: C
+    }, d.renderDragPreview) : null;
+  }
+  if (h && d) {
+    x = d.useDroppableCollectionState({
+      collection: n,
+      selectionManager: p
+    });
+    let I = new Cl({
+      collection: n,
+      disabledKeys: p.disabledKeys,
+      disabledBehavior: p.disabledBehavior,
+      ref: e,
+      layoutDelegate: u
+    }), Q = d.dropTargetDelegate || a || new d.ListDropTargetDelegate(n.rows, e);
+    m = d.useDroppableCollection({
+      keyboardDelegate: I,
+      dropTargetDelegate: Q
+    }, x, e), $ = x.isDropTarget({
+      type: "root"
+    });
+  }
+  let { focusProps: k, isFocused: P, isFocusVisible: K } = ce(), E = re({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-Table",
+    values: {
+      isDropTarget: $,
+      isFocused: P,
+      isFocusVisible: K,
+      state: r
+    }
+  }), N = !!(f && !v?.isDisabled), F = E.style, V = null;
+  o && (V = o.useTableColumnResizeState({
+    tableWidth: o.tableWidth
+  }, r), i || (F = {
+    ...F,
+    tableLayout: "fixed",
+    width: "fit-content"
+  }));
+  let z = U("table"), R = J(t, {
+    global: !0
+  });
+  var j;
+  return /* @__PURE__ */ w.createElement(ze, {
+    values: [
+      [
+        _,
+        r
+      ],
+      [
+        Oe,
+        V
+      ],
+      [
+        fe,
+        {
+          dragAndDropHooks: d,
+          dragState: v,
+          dropState: x
+        }
+      ],
+      [
+        El,
+        {
+          render: Jn
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ w.createElement(Vl, null, /* @__PURE__ */ w.createElement(z, {
+    ...H(R, E, s, k, m?.collectionProps),
+    style: F,
+    ref: e,
+    slot: t.slot || void 0,
+    onScroll: t.onScroll,
+    "data-allows-dragging": N || void 0,
+    "data-drop-target": $ || void 0,
+    "data-focused": P || void 0,
+    "data-focus-visible": K || void 0
+  }, /* @__PURE__ */ w.createElement(c, {
+    collection: n,
+    scrollRef: (j = o?.scrollRef) !== null && j !== void 0 ? j : e,
+    persistedKeys: zl(p, d, x)
+  }))), b);
+}
+function U(t) {
+  let { isVirtualized: e } = A(Z);
+  return e ? "div" : t;
+}
+const al = /* @__PURE__ */ ie(null);
+function ul() {
+  return A(al);
+}
+const Ln = /* @__PURE__ */ Fe("tableheader", (t, e) => {
+  let l = A(_).collection, n = xl({
+    items: l.headerRows,
+    children: O((c) => {
+      switch (c.type) {
+        case "headerrow":
+          return /* @__PURE__ */ w.createElement(Yn, {
+            item: c
+          });
+        default:
+          throw new Error("Unsupported node type in TableHeader: " + c.type);
+      }
+    }, [])
+  }), o = U("thead"), { rowGroupProps: r } = ll(), { hoverProps: i, isHovered: u } = xe({
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), a = re({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-TableHeader",
+    values: {
+      isHovered: u
+    }
+  });
+  return /* @__PURE__ */ w.createElement(o, {
+    ...H(J(t, {
+      global: !0
+    }), r, i),
+    ...a,
+    ref: e,
+    "data-hovered": u || void 0
+  }, n);
+}, (t) => /* @__PURE__ */ w.createElement($e, {
+  dependencies: t.dependencies,
+  items: t.columns
+}, t.children));
+function Yn({ item: t }) {
+  let e = M(null), l = A(_), { isVirtualized: n, CollectionBranch: o } = A(Z), { rowProps: r } = xn({
+    node: t,
+    isVirtualized: n
+  }, l, e), { checkboxProps: i } = kn(l), u = U("tr");
+  return /* @__PURE__ */ w.createElement(u, {
+    ...r,
+    ref: e
+  }, /* @__PURE__ */ w.createElement(ze, {
+    values: [
+      [
+        ut,
+        {
+          slots: {
+            selection: i
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ w.createElement(o, {
+    collection: l.collection,
+    parent: t
+  })));
+}
+const Xn = /* @__PURE__ */ ct("column", (t, e, l) => {
+  var n, o;
+  let r = ae(e), i = A(_), { isVirtualized: u } = A(Z), { columnHeaderProps: a } = yn({
+    node: l,
+    isVirtualized: u
+  }, i, r), { isFocused: c, isFocusVisible: d, focusProps: s } = ce(), p = A(Oe), f = !1;
+  if (p) f = p.resizingColumn === l.key;
+  else if (process.env.NODE_ENV !== "production")
+    for (let $ in [
+      "width",
+      "defaultWidth",
+      "minWidth",
+      "maxWidth"
+    ]) $ in l.props && console.warn(`The ${$} prop on a <Column> only applies when a <Table> is wrapped in a <ResizableTableContainer>. If you aren't using column resizing, you can set the width of a column with CSS.`);
+  let { hoverProps: h, isHovered: g } = xe({
+    isDisabled: !t.allowsSorting
+  }), y = re({
+    ...t,
+    id: void 0,
+    children: l.rendered,
+    defaultClassName: "react-aria-Column",
+    values: {
+      isHovered: g,
+      isFocused: c,
+      isFocusVisible: d,
+      allowsSorting: l.props.allowsSorting,
+      sortDirection: ((n = i.sortDescriptor) === null || n === void 0 ? void 0 : n.column) === l.key ? i.sortDescriptor.direction : void 0,
+      isResizing: f,
+      startResize: () => {
+        if (p)
+          p.startResize(l.key), i.setKeyboardNavigationDisabled(!0);
+        else throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+      },
+      sort: ($) => {
+        i.sort(l.key, $);
+      }
+    }
+  }), v = y.style;
+  p && (v = {
+    ...v,
+    width: p.getColumnWidth(l.key)
+  });
+  let x = U("th"), m = J(t, {
+    global: !0
+  });
+  return delete m.id, /* @__PURE__ */ w.createElement(x, {
+    ...H(m, a, s, h),
+    ...y,
+    style: v,
+    ref: r,
+    "data-hovered": g || void 0,
+    "data-focused": c || void 0,
+    "data-focus-visible": d || void 0,
+    "data-resizing": f || void 0,
+    "data-allows-sorting": l.props.allowsSorting || void 0,
+    "data-sort-direction": ((o = i.sortDescriptor) === null || o === void 0 ? void 0 : o.column) === l.key ? i.sortDescriptor.direction : void 0
+  }, /* @__PURE__ */ w.createElement(ze, {
+    values: [
+      [
+        sl,
+        {
+          column: l,
+          triggerRef: r
+        }
+      ],
+      [
+        Z,
+        ft
+      ]
+    ]
+  }, y.children));
+}), sl = /* @__PURE__ */ ie(null), qn = /* @__PURE__ */ Y(function(e, l) {
+  let n = A(Oe);
+  if (!n) throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+  let o = he(Wn(Al), "react-aria-components"), { onResizeStart: r, onResize: i, onResizeEnd: u } = A(je), { column: a, triggerRef: c } = A(sl), d = M(null), { resizerProps: s, inputProps: p, isResizing: f } = En({
+    column: a,
+    "aria-label": e["aria-label"] || o.format("tableResizer"),
+    onResizeStart: r,
+    onResize: i,
+    onResizeEnd: u,
+    triggerRef: c
+  }, n, d), { focusProps: h, isFocused: g, isFocusVisible: y } = ce(), { hoverProps: v, isHovered: x } = xe(e), m = n.getColumnMinWidth(a.key) >= n.getColumnWidth(a.key), $ = n.getColumnMaxWidth(a.key) <= n.getColumnWidth(a.key), { direction: b } = pe(), C = "both";
+  m ? C = b === "rtl" ? "right" : "left" : $ ? C = b === "rtl" ? "left" : "right" : C = "both";
+  let k = ae(l), [P, K] = G("");
+  oe(() => {
+    if (!k.current) return;
+    let R = window.getComputedStyle(k.current);
+    K(R.cursor);
+  }, [
+    k,
+    C
+  ]);
+  let E = re({
+    ...e,
+    defaultClassName: "react-aria-ColumnResizer",
+    values: {
+      isFocused: g,
+      isFocusVisible: y,
+      isResizing: f,
+      isHovered: x,
+      resizableDirection: C
+    }
+  }), [N, F] = G(!1), V = (R) => {
+    R.pointerType === "mouse" && F(!0);
+  };
+  !f && N && F(!1);
+  let z = J(e, {
+    global: !0
+  });
+  return /* @__PURE__ */ w.createElement("div", {
+    ref: k,
+    role: "presentation",
+    ...H(z, E, s, {
+      onPointerDown: V
+    }, v),
+    "data-hovered": x || void 0,
+    "data-focused": g || void 0,
+    "data-focus-visible": y || void 0,
+    "data-resizing": f || void 0,
+    "data-resizable-direction": C
+  }, E.children, /* @__PURE__ */ w.createElement("input", {
+    ref: d,
+    ...H(p, h)
+  }), f && N && /* @__PURE__ */ Kl.createPortal(/* @__PURE__ */ w.createElement("div", {
+    style: {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      bottom: 0,
+      right: 0,
+      cursor: P
+    }
+  }), document.body));
+}), Gn = /* @__PURE__ */ Fe("tablebody", (t, e) => {
+  let l = A(_), { isVirtualized: n } = A(Z), o = l.collection, { CollectionBranch: r } = A(Z), { dragAndDropHooks: i, dropState: u } = A(fe), a = !!i?.useDroppableCollectionState && !u?.isDisabled;
+  var c;
+  let d = a && !!u && ((c = u.isDropTarget({
+    type: "root"
+  })) !== null && c !== void 0 ? c : !1), s = o.size === 0, p = {
+    isDropTarget: d,
+    isEmpty: s
+  }, f = re({
+    ...t,
+    id: void 0,
+    children: void 0,
+    defaultClassName: "react-aria-TableBody",
+    values: p
+  }), h, g = U("tr"), y = U("td"), v = o.columnCount;
+  if (s && t.renderEmptyState && l) {
+    let b = {}, C = {}, k = {};
+    n ? (C["aria-colspan"] = v, k = {
+      display: "contents"
+    }) : C.colSpan = v, h = /* @__PURE__ */ w.createElement(g, {
+      role: "row",
+      ...b,
+      style: k
+    }, /* @__PURE__ */ w.createElement(y, {
+      role: "rowheader",
+      ...C,
+      style: k
+    }, t.renderEmptyState(p)));
+  }
+  let { rowGroupProps: x } = ll(), m = U("tbody"), $ = J(t, {
+    global: !0
+  });
+  return /* @__PURE__ */ w.createElement(m, {
+    ...H($, f, x),
+    ref: e,
+    "data-empty": s || void 0
+  }, a && /* @__PURE__ */ w.createElement(eo, null), /* @__PURE__ */ w.createElement(r, {
+    collection: o,
+    parent: o.body,
+    renderDropIndicator: Sl(i, u)
+  }), h);
+}), nt = /* @__PURE__ */ Fe("item", (t, e, l) => {
+  let n = ae(e), o = A(_), { dragAndDropHooks: r, dragState: i, dropState: u } = A(fe), { isVirtualized: a, CollectionBranch: c } = A(Z), { rowProps: d, ...s } = $n({
+    node: l,
+    shouldSelectOnPressUp: !!i,
+    isVirtualized: a
+  }, o, n), { isFocused: p, isFocusVisible: f, focusProps: h } = ce(), { isFocusVisible: g, focusProps: y } = ce({
+    within: !0
+  }), { hoverProps: v, isHovered: x } = xe({
+    isDisabled: !s.allowsSelection && !s.hasAction,
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), { checkboxProps: m } = wn({
+    key: l.key
+  }, o), $;
+  i && r && ($ = r.useDraggableItem({
+    key: l.key,
+    hasDragButton: !0
+  }, i));
+  let b, C = M(null), { visuallyHiddenProps: k } = Re();
+  u && r && (b = r.useDropIndicator({
+    target: {
+      type: "item",
+      key: l.key,
+      dropPosition: "on"
+    }
+  }, u, C));
+  let P = M(null);
+  oe(() => {
+    i && !P.current && process.env.NODE_ENV !== "production" && console.warn('Draggable items in a Table must contain a <Button slot="drag"> element so that keyboard and screen reader users can drag them.');
+  }, []);
+  let K = i && i.isDragging(l.key), { children: E, ...N } = t, F = re({
+    ...N,
+    id: void 0,
+    defaultClassName: "react-aria-Row",
+    values: {
+      ...s,
+      isHovered: x,
+      isFocused: p,
+      isFocusVisible: f,
+      selectionMode: o.selectionManager.selectionMode,
+      selectionBehavior: o.selectionManager.selectionBehavior,
+      isDragging: K,
+      isDropTarget: b?.isDropTarget,
+      isFocusVisibleWithin: g,
+      id: l.key
+    }
+  }), V = U("tr"), z = U("td"), R = J(t, {
+    global: !0
+  });
+  return delete R.id, delete R.onClick, /* @__PURE__ */ w.createElement(w.Fragment, null, b && !b.isHidden && /* @__PURE__ */ w.createElement(V, {
+    role: "row",
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ w.createElement(z, {
+    role: "gridcell",
+    colSpan: o.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ w.createElement("div", {
+    role: "button",
+    ...k,
+    ...b.dropIndicatorProps,
+    ref: C
+  }))), /* @__PURE__ */ w.createElement(V, {
+    ...H(R, F, d, h, v, $?.dragProps, y),
+    ref: n,
+    "data-disabled": s.isDisabled || void 0,
+    "data-selected": s.isSelected || void 0,
+    "data-hovered": x || void 0,
+    "data-focused": s.isFocused || void 0,
+    "data-focus-visible": f || void 0,
+    "data-pressed": s.isPressed || void 0,
+    "data-dragging": K || void 0,
+    "data-drop-target": b?.isDropTarget || void 0,
+    "data-selection-mode": o.selectionManager.selectionMode === "none" ? void 0 : o.selectionManager.selectionMode,
+    "data-focus-visible-within": g || void 0
+  }, /* @__PURE__ */ w.createElement(ze, {
+    values: [
+      [
+        ut,
+        {
+          slots: {
+            [Je]: {},
+            selection: m
+          }
+        }
+      ],
+      [
+        at,
+        {
+          slots: {
+            [Je]: {},
+            drag: {
+              ...$?.dragButtonProps,
+              ref: P,
+              style: {
+                pointerEvents: "none"
+              }
+            }
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ w.createElement(c, {
+    collection: o.collection,
+    parent: l
+  }))));
+}, (t) => {
+  if (t.id == null && typeof t.children == "function") throw new Error("No id detected for the Row element. The Row element requires a id to be provided to it when the cells are rendered dynamically.");
+  let e = [
+    t.value
+  ].concat(t.dependencies);
+  return /* @__PURE__ */ w.createElement($e, {
+    dependencies: e,
+    items: t.columns,
+    idScope: t.id
+  }, t.children);
+}), Zn = /* @__PURE__ */ ct("cell", (t, e, l) => {
+  let n = ae(e), o = A(_), { dragState: r } = A(fe), { isVirtualized: i } = A(Z);
+  l.column = o.collection.columns[l.index];
+  let { gridCellProps: u, isPressed: a } = Dn({
+    node: l,
+    shouldSelectOnPressUp: !!r,
+    isVirtualized: i
+  }, o, n), { isFocused: c, isFocusVisible: d, focusProps: s } = ce(), { hoverProps: p, isHovered: f } = xe({}), h = re({
+    ...t,
+    id: void 0,
+    defaultClassName: "react-aria-Cell",
+    values: {
+      isFocused: c,
+      isFocusVisible: d,
+      isPressed: a,
+      isHovered: f,
+      id: l.key
+    }
+  }), g = U("td"), y = J(t, {
+    global: !0
+  });
+  return delete y.id, /* @__PURE__ */ w.createElement(g, {
+    ...H(y, h, u, s, p),
+    ref: n,
+    "data-focused": c || void 0,
+    "data-focus-visible": d || void 0,
+    "data-pressed": a || void 0
+  }, /* @__PURE__ */ w.createElement(Z.Provider, {
+    value: ft
+  }, h.children));
+});
+function Jn(t, e) {
+  e = ae(e);
+  let { dragAndDropHooks: l, dropState: n } = A(fe), o = M(null), { dropIndicatorProps: r, isHidden: i, isDropTarget: u } = l.useDropIndicator(t, n, o);
+  return i ? null : /* @__PURE__ */ w.createElement(_n, {
+    ...t,
+    dropIndicatorProps: r,
+    isDropTarget: u,
+    buttonRef: o,
+    ref: e
+  });
+}
+function Qn(t, e) {
+  let { dropIndicatorProps: l, isDropTarget: n, buttonRef: o, ...r } = t, i = A(_), { visuallyHiddenProps: u } = Re(), a = re({
+    ...r,
+    defaultClassName: "react-aria-DropIndicator",
+    values: {
+      isDropTarget: n
+    }
+  }), c = U("tr"), d = U("td");
+  return /* @__PURE__ */ w.createElement(c, {
+    ...J(t, {
+      global: !0
+    }),
+    ...a,
+    role: "row",
+    ref: e,
+    "data-drop-target": n || void 0
+  }, /* @__PURE__ */ w.createElement(d, {
+    role: "gridcell",
+    colSpan: i.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ w.createElement("div", {
+    ...u,
+    role: "button",
+    ...l,
+    ref: o
+  }), a.children));
+}
+const _n = /* @__PURE__ */ Y(Qn);
+function eo() {
+  let t = A(_), { dragAndDropHooks: e, dropState: l } = A(fe), n = M(null), { dropIndicatorProps: o } = e.useDropIndicator({
+    target: {
+      type: "root"
+    }
+  }, l, n), r = l.isDropTarget({
+    type: "root"
+  }), { visuallyHiddenProps: i } = Re(), u = U("tr"), a = U("td");
+  return !r && o["aria-hidden"] ? null : /* @__PURE__ */ w.createElement(u, {
+    role: "row",
+    "aria-hidden": o["aria-hidden"],
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ w.createElement(a, {
+    role: "gridcell",
+    colSpan: t.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ w.createElement("div", {
+    role: "button",
+    ...i,
+    ...o,
+    ref: n
+  })));
+}
+const { withContext: to } = /* @__PURE__ */ on({
+  key: "mark"
+}), lo = /* @__PURE__ */ to("mark"), Be = /* @__PURE__ */ ie(null);
+Be.displayName = "DataTableContext";
+const me = () => {
+  const t = A(
+    Be
+  );
+  if (!t)
+    throw new Error("DataTable components must be used within DataTable.Root");
+  return t;
+};
+var dl = (t, e) => {
+  const l = [], n = (o, r, i) => {
+    r - o > 0 && l.push({ start: o, end: r, match: i });
+  };
+  if (t.length === 0)
+    n(0, e, !1);
+  else {
+    let o = 0;
+    for (const r of t)
+      n(o, r.start, !1), n(r.start, r.end, !0), o = r.end;
+    n(o, e, !1);
+  }
+  return l;
+};
+function no(t) {
+  const { text: e, query: l, ignoreCase: n } = t, o = n ? e.toLowerCase() : e, r = n && typeof l == "string" ? l.toLowerCase() : l, i = typeof o == "string" ? o.indexOf(r) : -1;
+  if (i === -1)
+    return [{ text: e, match: !1 }];
+  const u = i + r.length;
+  return dl([{ start: i, end: u }], e.length).map((c) => ({
+    text: e.slice(c.start, c.end),
+    match: !!c.match
+  }));
+}
+var oo = (t) => t.replace(/[|\\{}()[\]^$+*?.-]/g, (e) => `\\${e}`), ro = (t, e) => {
+  const l = t.filter(Boolean).map((n) => oo(n));
+  return new RegExp(`(${l.join("|")})`, e);
+}, io = (t, e = !0) => `${t ? "i" : ""}${e ? "g" : ""}`;
+function ao(t) {
+  const { text: e, query: l, ignoreCase: n, matchAll: o } = t;
+  if (l.length === 0)
+    return [{ text: e, match: !1 }];
+  const r = io(n, o), i = ro(Array.isArray(l) ? l : [l], r), u = [...e.matchAll(i)].map((a) => ({
+    start: a.index || 0,
+    end: (a.index || 0) + a[0].length
+  }));
+  return dl(u, t.text.length).map((a) => ({
+    text: t.text.slice(a.start, a.end),
+    match: !!a.match
+  }));
+}
+var uo = (t) => {
+  if (t.matchAll == null && (t.matchAll = Array.isArray(t.query)), !t.matchAll && Array.isArray(t.query))
+    throw new Error("matchAll must be true when using multiple queries");
+  return t.matchAll ? ao(t) : no(t);
+};
+const so = (t) => T(() => uo(t), [t]);
+function co(t) {
+  const { each: e, fallback: l, children: n } = t;
+  return e?.length === 0 ? l || null : e?.map(n);
+}
+function fo(t) {
+  const { children: e, query: l, ignoreCase: n, matchAll: o, styles: r } = t;
+  if (typeof e != "string")
+    throw new Error("The children prop of Highlight must be a string");
+  const i = so({
+    query: l,
+    text: e,
+    matchAll: o,
+    ignoreCase: n
+  });
+  return /* @__PURE__ */ D(co, { each: i, children: (u, a) => u.match ? /* @__PURE__ */ D(lo, { css: r, children: u.text }, a) : /* @__PURE__ */ D(ml, { children: u.text }, a) });
+}
+const de = /* @__PURE__ */ Y(function({ children: e, isDisabled: l, ...n }, o) {
+  return /* @__PURE__ */ D(Zn, { ref: o, ...n, children: (r) => /* @__PURE__ */ D(at.Provider, { value: { isDisabled: l }, children: typeof e == "function" ? e(r) : e }) });
+}), po = /* @__PURE__ */ Gl({
+  // Available slots for the DataTable component
+  slots: [
+    "root",
+    "table",
+    "column",
+    "footer",
+    "selectionCell",
+    "detailsButton",
+    "expandButton",
+    "nestedIcon",
+    "headerSortIcon",
+    "columnResizer"
+  ],
+  className: "nimbus-data-table",
+  base: {
+    root: {
+      colorPalette: "slate",
+      display: "block",
+      borderRadius: "8px",
+      border: "1px solid {colors.neutral.3}",
+      boxShadow: "1",
+      overflow: "auto",
+      contain: "layout style",
+      "& .react-aria-Cell": {
+        paddingTop: "400",
+        paddingBottom: "400",
+        paddingLeft: "600",
+        paddingRight: "600",
+        color: "neutral.11",
+        focusRing: "outside",
+        hyphens: "auto",
+        "&[data-slot='expand']": {
+          padding: 0
+        },
+        "& .nimbus-table-cell-copy-button": {
+          display: "none"
+        },
+        _hover: {
+          "& > div > .nimbus-table-cell-copy-button": {
+            display: "inherit"
+          }
+        }
+      },
+      "& .data-table-row": {
+        borderBottom: "1px solid {colors.neutral.3}",
+        focusRing: "outside",
+        "& td, div": {
+          userSelect: "text"
+        },
+        "&:last-child": {
+          borderBottom: "none"
+        },
+        _hover: {
+          backgroundColor: "{colors.primary.3}",
+          transition: "background-color 100ms ease",
+          transform: "translate3d(0, 0, 0)",
+          "& .data-table-row-details-button": {
+            opacity: 1
+          }
+        },
+        "& .data-table-row-details-button": {
+          opacity: 0
+        },
+        "& .data-table-row-details-button:focus": {
+          opacity: 1
+        }
+      },
+      "& .data-table-row[data-selected='true']": {
+        background: "{colors.primary.4}"
+      },
+      "& .data-table-row[data-disabled='true']": {
+        "& .data-table-row-details-button": {
+          display: "none"
+        },
+        // layerStyle: "disabled",
+        opacity: 0.8,
+        cursor: "not-allowed"
+      },
+      "& .data-table-header": {
+        background: "colorPalette.2",
+        color: "colorPalette.11",
+        borderBottom: "1px solid {colors.neutral.3}",
+        lineHeight: "400",
+        fontWeight: "500",
+        textStyle: "sm",
+        fontSize: "300",
+        height: "1000",
+        "& .data-table-column-divider": {
+          display: "none",
+          position: "absolute",
+          right: 0,
+          top: "10%",
+          bottom: "10%",
+          height: "80%",
+          width: "1px",
+          pointerEvents: "none"
+        },
+        _hover: {
+          "& .data-table-column-divider": {
+            display: "inherit"
+          },
+          "& tr th:last-of-type .data-table-column-divider": {
+            display: "none"
+          }
+        }
+      }
+      // Multiline header truncation using webkit line clamp
+    },
+    table: {
+      width: "fit-content",
+      tableLayout: "fixed"
+    },
+    column: {
+      textAlign: "right",
+      position: "relative",
+      paddingTop: "100",
+      paddingBottom: "100",
+      paddingLeft: "600",
+      paddingRight: "600",
+      lineHeight: "450",
+      focusVisibleRing: "outside",
+      focusRing: "outside",
+      _focus: {
+        focusRing: "outside"
+      },
+      "& .nimbus-data-table__headerSortIcon": {
+        display: "none"
+      },
+      "& > div": {
+        display: "flex",
+        alignItems: "center",
+        "& > span:first-of-type": {
+          overflow: "hidden",
+          textOverflow: "ellipsis",
+          whiteSpace: "nowrap"
+        },
+        "& span[data-multiline-header]": {
+          overflow: "hidden",
+          lineHeight: "450",
+          wordBreak: "break-word",
+          whiteSpace: "normal",
+          textOverflow: "ellipsis",
+          textAlign: "left",
+          display: "-webkit-box",
+          WebkitLineClamp: 2,
+          WebkitBoxOrient: "vertical"
+        },
+        "& > span:not(:first-of-type)": {
+          flexShrink: 0
+        }
+      },
+      "&.selection-column-header, &.expand-column-header": {
+        cursor: "default",
+        "&:hover": {
+          backgroundColor: "transparent"
+        }
+      },
+      "&.expand-column-header": {
+        padding: "0"
+      },
+      "&[aria-sort]": {
+        fontWeight: 600,
+        cursor: "pointer",
+        "&[aria-sort='none']:hover": {
+          "& .nimbus-data-table__headerSortIcon": {
+            display: "inherit"
+          }
+        },
+        "&[aria-sort='ascending'], &[aria-sort='descending']": {
+          "& .nimbus-data-table__headerSortIcon": {
+            display: "inherit"
+          }
+        },
+        "&[aria-sort='ascending']": {
+          "& .nimbus-data-table__headerSortIcon": {
+            transform: "rotate(180deg)"
+          }
+        }
+      }
+    },
+    footer: {
+      width: "100%"
+    },
+    selectionCell: {},
+    detailsButton: {},
+    expandButton: {},
+    nestedIcon: {},
+    headerSortIcon: {
+      transition: "transform 100ms cubic-bezier(0.4, 0.0, 0.2, 1)",
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      marginLeft: "6px",
+      width: "16px",
+      height: "16px",
+      willChange: "opacity, color, transform"
+    },
+    columnResizer: {
+      width: "4px",
+      height: "100%",
+      position: "absolute",
+      right: 0,
+      top: 0,
+      cursor: "col-resize",
+      transition: "background 100ms",
+      background: "transparent",
+      outline: "none",
+      zIndex: 2,
+      "&[data-resizing='true']": {
+        background: "{colors.primary}"
+      },
+      "&[data-focused='true']": {
+        outline: "1px solid {colors.primary}"
+      }
+    }
+  },
+  // Variants for different states
+  variants: {
+    truncated: {
+      true: {
+        root: {
+          "& .truncated-cell": {
+            maxWidth: "200px",
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap"
+          }
+        }
+      }
+    },
+    density: {
+      default: {
+        root: {
+          "& .react-aria-Cell": {
+            paddingTop: "400",
+            paddingBottom: "400"
+          }
+        }
+      },
+      condensed: {
+        root: {
+          "& .react-aria-Cell": {
+            paddingTop: "300",
+            paddingBottom: "300"
+          }
+        }
+      }
+    }
+  }
+}), { withProvider: ho, withContext: ee } = /* @__PURE__ */ Zl({
+  key: "data-table",
+  recipe: po
+}), mo = /* @__PURE__ */ ho(
+  "div",
+  "root"
+), go = /* @__PURE__ */ ee("table", "table"), bo = /* @__PURE__ */ ee("th", "column"), vo = /* @__PURE__ */ ee("footer", "footer"), yo = /* @__PURE__ */ ee("td", "selectionCell"), $o = /* @__PURE__ */ ee("button", "detailsButton"), cl = /* @__PURE__ */ ee("button", "expandButton"), xo = /* @__PURE__ */ ee("span", "nestedIcon"), Do = /* @__PURE__ */ ee("span", "headerSortIcon"), Co = /* @__PURE__ */ ee("div", "columnResizer");
+function wo() {
+  var t = M(!1), e = O(function() {
+    return t.current;
+  }, []);
+  return oe(function() {
+    return t.current = !0, function() {
+      t.current = !1;
+    };
+  }, []), e;
+}
+var ko = function(t) {
+  t === void 0 && (t = {});
+  var e = G(t), l = e[0], n = e[1], o = O(function(r) {
+    n(function(i) {
+      return Object.assign({}, i, r instanceof Function ? r(i) : r);
+    });
+  }, []);
+  return [l, o];
+}, Ke, ot;
+function So() {
+  return ot || (ot = 1, Ke = function() {
+    var t = document.getSelection();
+    if (!t.rangeCount)
+      return function() {
+      };
+    for (var e = document.activeElement, l = [], n = 0; n < t.rangeCount; n++)
+      l.push(t.getRangeAt(n));
+    switch (e.tagName.toUpperCase()) {
+      // .toUpperCase handles XHTML
+      case "INPUT":
+      case "TEXTAREA":
+        e.blur();
+        break;
+      default:
+        e = null;
+        break;
+    }
+    return t.removeAllRanges(), function() {
+      t.type === "Caret" && t.removeAllRanges(), t.rangeCount || l.forEach(function(o) {
+        t.addRange(o);
+      }), e && e.focus();
+    };
+  }), Ke;
+}
+var Me, rt;
+function Eo() {
+  if (rt) return Me;
+  rt = 1;
+  var t = So(), e = {
+    "text/plain": "Text",
+    "text/html": "Url",
+    default: "Text"
+  }, l = "Copy to clipboard: #{key}, Enter";
+  function n(r) {
+    var i = (/mac os x/i.test(navigator.userAgent) ? "⌘" : "Ctrl") + "+C";
+    return r.replace(/#{\s*key\s*}/g, i);
+  }
+  function o(r, i) {
+    var u, a, c, d, s, p, f = !1;
+    i || (i = {}), u = i.debug || !1;
+    try {
+      c = t(), d = document.createRange(), s = document.getSelection(), p = document.createElement("span"), p.textContent = r, p.ariaHidden = "true", p.style.all = "unset", p.style.position = "fixed", p.style.top = 0, p.style.clip = "rect(0, 0, 0, 0)", p.style.whiteSpace = "pre", p.style.webkitUserSelect = "text", p.style.MozUserSelect = "text", p.style.msUserSelect = "text", p.style.userSelect = "text", p.addEventListener("copy", function(g) {
+        if (g.stopPropagation(), i.format)
+          if (g.preventDefault(), typeof g.clipboardData > "u") {
+            u && console.warn("unable to use e.clipboardData"), u && console.warn("trying IE specific stuff"), window.clipboardData.clearData();
+            var y = e[i.format] || e.default;
+            window.clipboardData.setData(y, r);
+          } else
+            g.clipboardData.clearData(), g.clipboardData.setData(i.format, r);
+        i.onCopy && (g.preventDefault(), i.onCopy(g.clipboardData));
+      }), document.body.appendChild(p), d.selectNodeContents(p), s.addRange(d);
+      var h = document.execCommand("copy");
+      if (!h)
+        throw new Error("copy command was unsuccessful");
+      f = !0;
+    } catch (g) {
+      u && console.error("unable to copy using execCommand: ", g), u && console.warn("trying IE specific stuff");
+      try {
+        window.clipboardData.setData(i.format || "text", r), i.onCopy && i.onCopy(window.clipboardData), f = !0;
+      } catch (y) {
+        u && console.error("unable to copy using clipboardData: ", y), u && console.error("falling back to prompt"), a = n("message" in i ? i.message : l), window.prompt(a, r);
+      }
+    } finally {
+      s && (typeof s.removeRange == "function" ? s.removeRange(d) : s.removeAllRanges()), p && document.body.removeChild(p), c();
+    }
+    return f;
+  }
+  return Me = o, Me;
+}
+var zo = /* @__PURE__ */ Eo();
+const Ao = /* @__PURE__ */ an(zo);
+var Ro = function() {
+  var t = wo(), e = ko({
+    value: void 0,
+    error: void 0,
+    noUserInteraction: !0
+  }), l = e[0], n = e[1], o = O(function(r) {
+    if (t()) {
+      var i, u;
+      try {
+        if (typeof r != "string" && typeof r != "number") {
+          var a = new Error("Cannot copy typeof " + typeof r + " to clipboard, must be a string");
+          process.env.NODE_ENV === "development" && console.error(a), n({
+            value: r,
+            error: a,
+            noUserInteraction: !0
+          });
+          return;
+        } else if (r === "") {
+          var a = new Error("Cannot copy empty string to clipboard.");
+          process.env.NODE_ENV === "development" && console.error(a), n({
+            value: r,
+            error: a,
+            noUserInteraction: !0
+          });
+          return;
+        }
+        u = r.toString(), i = Ao(u), n({
+          value: u,
+          error: void 0,
+          noUserInteraction: i
+        });
+      } catch (c) {
+        n({
+          value: u,
+          error: c,
+          noUserInteraction: i
+        });
+      }
+    }
+  }, []);
+  return [l, o];
+};
+const Ue = /* @__PURE__ */ Y(function({ row: e, depth: l = 0 }, n) {
+  const {
+    activeColumns: o,
+    search: r,
+    expanded: i,
+    toggleExpand: u,
+    nestedKey: a,
+    disabledKeys: c,
+    showExpandColumn: d,
+    showSelectionColumn: s,
+    showDetailsColumn: p,
+    isRowClickable: f,
+    isTruncated: h,
+    onRowClick: g,
+    onDetailsClick: y,
+    onRowAction: v
+  } = me(), m = ((z) => c ? c === "all" || e.isDisabled ? !0 : c.has(z) : !1)(e.id), $ = (z) => {
+    !z.target?.closest(
+      'button, input, [role="button"], [role="checkbox"], [slot="selection"], [data-slot="selection"]'
+    ) && f && g && (m ? v && v(e, "click") : g(e));
+  }, b = M({
+    count: 0,
+    node: void 0
+  }), C = O(
+    (z) => {
+      b.current.count += 1, b.current.count === 1 && z && f && (b.current.node = z, z.addEventListener("click", $, { capture: !0 }));
+    },
+    [f, $]
+  );
+  oe(() => () => {
+    b.current.count >= 1 && b.current.node && b.current.node.removeEventListener("click", $);
+  }, [$]);
+  const k = Jl(n, C), { selectionBehavior: P } = ul(), [, K] = Ro(), E = a && e[a] && (Array.isArray(e[a]) ? e[a].length > 0 : !0), N = i[e.id], F = (z) => {
+    const R = typeof z == "string" ? z : String(z);
+    K(R);
+  }, V = (z) => r && typeof z == "string" ? /* @__PURE__ */ D(fo, { query: r, ignoreCase: !0, matchAll: !0, children: z }) : z;
+  return /* @__PURE__ */ ne(it, { children: [
+    /* @__PURE__ */ ne(
+      nt,
+      {
+        isDisabled: m,
+        columns: o,
+        ref: k,
+        id: e.id,
+        className: `data-table-row ${m ? "data-table-row-disabled" : ""}`,
+        style: {
+          cursor: m ? "not-allowed" : f ? "pointer" : void 0,
+          position: "relative",
+          ...l > 0 && {
+            borderLeft: "2px solid var(--colors-primary-6)",
+            backgroundColor: "var(--colors-slate-2)"
+          }
+        },
+        dependencies: [N, r, h],
+        children: [
+          P === "toggle" && /* @__PURE__ */ D(de, { "data-slot": "selection", isDisabled: m, children: /* @__PURE__ */ D(
+            ye,
+            {
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              w: "100%",
+              h: "100%",
+              children: /* @__PURE__ */ D(mt, { name: "select-row", slot: "selection" })
+            }
+          ) }),
+          d && /* @__PURE__ */ D(de, { "data-slot": "expand", isDisabled: m, children: E ? /* @__PURE__ */ D(
+            cl,
+            {
+              w: "100%",
+              h: "100%",
+              cursor: "pointer",
+              "aria-label": N ? "Collapse" : "Expand",
+              onClick: (z) => {
+                z.stopPropagation(), u(e.id);
+              },
+              children: N ? /* @__PURE__ */ D(en, {}) : /* @__PURE__ */ D(tn, {})
+            }
+          ) : null }),
+          /* @__PURE__ */ D($e, { items: o, children: (z) => {
+            const R = z.accessor(e);
+            return z.id === "nimbus-data-table-details-column" ? /* @__PURE__ */ D(
+              de,
+              {
+                isDisabled: m,
+                style: {
+                  alignItems: "center",
+                  justifyContent: "center"
+                },
+                children: /* @__PURE__ */ D(
+                  ye,
+                  {
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    w: "100%",
+                    h: "100%",
+                    children: /* @__PURE__ */ D(
+                      Ql,
+                      {
+                        "aria-label": "View row details",
+                        className: "data-table-row-details-button",
+                        disabled: m,
+                        variant: "outline",
+                        colorPalette: "primary",
+                        size: "2xs",
+                        onPress: () => {
+                          y && y(e);
+                        },
+                        children: "Open"
+                      }
+                    )
+                  }
+                )
+              },
+              "details-column"
+            ) : /* @__PURE__ */ D(de, { isDisabled: m, children: /* @__PURE__ */ ne(gt, { children: [
+              /* @__PURE__ */ D(
+                ye,
+                {
+                  className: h ? "truncated-cell" : "",
+                  display: "inline-block",
+                  h: "100%",
+                  minW: "0",
+                  maxW: "100%",
+                  position: "relative",
+                  overflow: "hidden",
+                  cursor: m ? "not-allowed" : "text",
+                  style: (
+                    // TODO: I'm not clear on what this is supposed to do?
+                    {
+                      // Add indentation for the first column of nested rows
+                      // ...(depth > 0 &&
+                      //   index === 0 && {
+                      //     paddingLeft: `${16 + depth * 16}px`,
+                      //   }),
+                    }
+                  ),
+                  children: z.render ? z.render({
+                    value: V(R),
+                    row: e,
+                    column: z
+                  }) : V(R)
+                }
+              ),
+              /* @__PURE__ */ D(
+                _l,
+                {
+                  size: "2xs",
+                  variant: "ghost",
+                  "aria-label": "Copy to clipboard",
+                  colorPalette: "primary",
+                  className: "nimbus-table-cell-copy-button",
+                  onPress: () => F(R),
+                  ml: "100",
+                  children: /* @__PURE__ */ D(
+                    ln,
+                    {
+                      onClick: () => F(R)
+                    },
+                    "copy-icon"
+                  )
+                },
+                "copy-btn"
+              )
+            ] }) }, z.id);
+          } })
+        ]
+      }
+    ),
+    d && /* @__PURE__ */ D(nt, { style: { display: N ? void 0 : "none" }, children: /* @__PURE__ */ D(
+      de,
+      {
+        isDisabled: m,
+        colSpan: o.length + (d ? 1 : 0) + (s ? 1 : 0) + (p ? 1 : 0) - // length is 1 indexed, but arrays/sets are 0 indexed, so we need to subtract 1 from the total
+        1,
+        style: {
+          borderLeft: "2px solid blue"
+        },
+        children: N ? a && Array.isArray(e[a]) ? `${e[a].length} nested items` : a && e[a] : null
+      }
+    ) })
+  ] });
+});
+Ue.displayName = "DataTable.Row";
+const Le = /* @__PURE__ */ Y(function(e, l) {
+  const { sortedRows: n, activeColumns: o } = me();
+  return /* @__PURE__ */ D(
+    Gn,
+    {
+      ref: l,
+      items: n,
+      dependencies: [o],
+      renderEmptyState: () => /* @__PURE__ */ D(ye, { w: "100%", p: "200", children: "No Data" }),
+      ...e,
+      children: (r) => /* @__PURE__ */ D(Ue, { row: r }, r.id)
+    }
+  );
+});
+Le.displayName = "DataTable.Body";
+const Se = ({
+  children: t,
+  ref: e,
+  column: l,
+  unstyled: n,
+  isInternalColumn: o,
+  tabIndex: r,
+  ...i
+}) => {
+  const { sortDescriptor: u, isResizable: a } = me(), c = u?.column === l?.id, d = l?.isResizable !== void 0 ? l?.isResizable : a;
+  return /* @__PURE__ */ D(bo, { unstyled: n, tabIndex: r, asChild: !0, children: /* @__PURE__ */ D(Xn, { ref: e, ...i, children: (s) => {
+    const { allowsSorting: p } = s;
+    return o ? typeof t == "function" ? t(s) : t : /* @__PURE__ */ ne(gt, { tabIndex: l?.isResizable ? 0 : -1, focusRing: "outside", children: [
+      /* @__PURE__ */ D(
+        rn,
+        {
+          orientation: "vertical",
+          className: "data-table-column-divider"
+        }
+      ),
+      typeof t == "function" ? t(s) : t,
+      p && /* @__PURE__ */ D(
+        Do,
+        {
+          "aria-hidden": "true",
+          color: c ? "neutral.11" : "neutral.10",
+          children: /* @__PURE__ */ D(nn, {})
+        }
+      ),
+      d && /* @__PURE__ */ D(qn, { "aria-label": "Resize column", children: ({ isResizing: f, isFocused: h }) => /* @__PURE__ */ D(
+        Co,
+        {
+          "data-resizing": f,
+          "data-focused": h
+        }
+      ) })
+    ] });
+  } }) });
+}, Ye = /* @__PURE__ */ Y(
+  function({ children: e, ...l }, n) {
+    return /* @__PURE__ */ D(vo, { ref: n, ...l, children: e });
+  }
+);
+Ye.displayName = "DataTable.Footer";
+const Xe = /* @__PURE__ */ Y(function(e, l) {
+  const { activeColumns: n, allowsSorting: o, maxHeight: r, showExpandColumn: i } = me(), { selectionBehavior: u, selectionMode: a } = ul();
+  return /* @__PURE__ */ ne(
+    Ln,
+    {
+      ref: l,
+      className: "data-table-header",
+      style: {
+        ...r && {
+          position: "sticky",
+          top: 0,
+          zIndex: 10
+        }
+      },
+      columns: n,
+      ...e,
+      children: [
+        u === "toggle" && /* @__PURE__ */ D(
+          Se,
+          {
+            id: "selection",
+            className: "selection-column-header",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            children: a === "multiple" && /* @__PURE__ */ D(mt, { slot: "selection" })
+          }
+        ),
+        i && /* @__PURE__ */ D(
+          Se,
+          {
+            className: "expand-column-header",
+            maxWidth: 24,
+            minWidth: 24,
+            allowsSorting: !1,
+            "aria-label": "Expand rows",
+            isInternalColumn: !0,
+            children: /* @__PURE__ */ D(tt, { children: "Expand rows" })
+          }
+        ),
+        /* @__PURE__ */ D($e, { items: n, children: (c) => {
+          const d = c.id === "nimbus-data-table-details-column";
+          return /* @__PURE__ */ D(
+            Se,
+            {
+              allowsSorting: (
+                // use column.isSortable if defined, and fallback to allowsSorting if not
+                c.isSortable !== void 0 ? c.isSortable : o
+              ),
+              isRowHeader: !d,
+              isInternalColumn: d,
+              width: c.width,
+              defaultWidth: c.defaultWidth,
+              minWidth: c.minWidth ?? 150,
+              maxWidth: c.maxWidth,
+              column: c,
+              children: d ? /* @__PURE__ */ D(tt, { children: "Details" }) : /* @__PURE__ */ ne(it, { children: [
+                /* @__PURE__ */ D("span", { "data-multiline-header": !0, children: c.header }),
+                c.headerIcon && /* @__PURE__ */ D(ye, { as: "span", ml: "200", children: c.headerIcon })
+              ] })
+            }
+          );
+        } })
+      ]
+    }
+  );
+});
+Xe.displayName = "DataTable.Header";
+function fl(t, e, l, n) {
+  if (!e) return t;
+  const o = e.toLowerCase();
+  return t.map((r) => {
+    const i = l.some((u) => {
+      const a = u.accessor(r);
+      return typeof a == "string" && a.toLowerCase().includes(o);
+    });
+    if (n && r[n]) {
+      let u = r[n];
+      if (Array.isArray(r[n])) {
+        if (u = fl(
+          r[n],
+          e,
+          l,
+          n
+        ), i || u && Array.isArray(u) && u.length > 0)
+          return { ...r, [n]: u };
+      } else if (i)
+        return { ...r, [n]: u };
+      return null;
+    } else
+      return i ? r : null;
+  }).filter(Boolean);
+}
+function pl(t, e, l, n) {
+  if (!e) return t;
+  const o = l.find((i) => i.id === e.column);
+  return o ? [...t].sort((i, u) => {
+    const a = o.accessor(i), c = o.accessor(u);
+    if (a == null && c == null) return 0;
+    if (a == null) return 1;
+    if (c == null) return -1;
+    let d = a, s = c;
+    return typeof a == "number" && typeof c == "number" ? (d = a, s = c) : (d = String(a).toLowerCase(), s = String(c).toLowerCase()), d < s ? e.direction === "ascending" ? -1 : 1 : d > s ? e.direction === "ascending" ? 1 : -1 : 0;
+  }).map((i) => !n || !i[n] ? i : {
+    ...i,
+    [n]: Array.isArray(i[n]) ? pl(i[n], e, l, n) : i[n]
+  }) : t;
+}
+function hl(t, e) {
+  return e ? t.some(
+    (l) => l[e] && (Array.isArray(l[e]) ? l[e].length > 0 : !0) || Array.isArray(l[e]) && hl(l[e], e)
+  ) : !1;
+}
+const qe = /* @__PURE__ */ Y(
+  function(e, l) {
+    const {
+      columns: n = [],
+      data: o = [],
+      visibleColumns: r,
+      search: i,
+      sortDescriptor: u,
+      onSortChange: a,
+      selectedKeys: c,
+      defaultSelectedKeys: d,
+      onSelectionChange: s,
+      selectionMode: p = "none",
+      disallowEmptySelection: f = !1,
+      allowsSorting: h = !1,
+      isRowClickable: g = !1,
+      maxHeight: y,
+      isTruncated: v = !1,
+      density: x = "default",
+      nestedKey: m,
+      onRowClick: $,
+      onDetailsClick: b,
+      disabledKeys: C,
+      onRowAction: k,
+      isResizable: P,
+      children: K,
+      ...E
+    } = e, [N, F] = G(), [V, z] = G({}), R = u ?? N, j = !0, I = T(() => {
+      const X = n.filter(
+        (be) => (r ? r.includes(be.id) : !0) && be.isVisible !== !1
+      );
+      return X.splice(1, 0, {
+        id: "nimbus-data-table-details-column",
+        header: void 0,
+        accessor: () => null,
+        width: 70,
+        isSortable: !1
+      }), X;
+    }, [n, r, j]), Q = T(
+      () => i ? fl(o, i, I, m) : o,
+      [o, i, I, m]
+    ), ge = T(
+      () => pl(Q, R, I, m),
+      [Q, R, I, m]
+    ), Ce = hl(ge, m), we = p !== "none", S = O(
+      (X) => z((be) => ({ ...be, [X]: !be[X] })),
+      []
+    ), B = O(
+      (X) => {
+        a ? a(X) : F(X);
+      },
+      [a]
+    ), L = T(
+      () => ({
+        columns: n,
+        data: o,
+        visibleColumns: r,
+        search: i,
+        sortDescriptor: R,
+        selectedKeys: c,
+        defaultSelectedKeys: d,
+        expanded: V,
+        allowsSorting: h,
+        selectionMode: p,
+        disallowEmptySelection: f,
+        isRowClickable: g,
+        maxHeight: y,
+        isTruncated: v,
+        density: x,
+        nestedKey: m,
+        onSortChange: B,
+        onSelectionChange: s,
+        onRowClick: $,
+        onDetailsClick: b,
+        toggleExpand: S,
+        activeColumns: I,
+        filteredRows: Q,
+        sortedRows: ge,
+        showExpandColumn: Ce,
+        showSelectionColumn: we,
+        showDetailsColumn: j,
+        isResizable: P,
+        disabledKeys: C,
+        onRowAction: k
+      }),
+      [
+        n,
+        o,
+        r,
+        i,
+        R,
+        c,
+        d,
+        V,
+        h,
+        p,
+        f,
+        g,
+        y,
+        v,
+        x,
+        m,
+        B,
+        s,
+        $,
+        b,
+        S,
+        I,
+        Q,
+        ge,
+        Ce,
+        we,
+        j,
+        P,
+        C,
+        k
+      ]
+    );
+    return /* @__PURE__ */ D(
+      mo,
+      {
+        ref: l,
+        truncated: v,
+        density: x,
+        style: {
+          ...y && {
+            maxHeight: y,
+            overflowY: "auto"
+          }
+        },
+        ...E,
+        asChild: !0,
+        children: /* @__PURE__ */ D(Hn, { children: /* @__PURE__ */ D(
+          Be.Provider,
+          {
+            value: L,
+            children: K
+          }
+        ) })
+      }
+    );
+  }
+);
+qe.displayName = "DataTableRoot";
+const Ge = /* @__PURE__ */ Y(function({ children: e, ...l }, n) {
+  const {
+    sortDescriptor: o,
+    onSortChange: r,
+    selectionMode: i,
+    onSelectionChange: u,
+    selectedKeys: a,
+    defaultSelectedKeys: c,
+    disallowEmptySelection: d,
+    disabledKeys: s
+  } = me(), p = o ? {
+    column: o.column,
+    direction: o.direction
+  } : void 0;
+  return /* @__PURE__ */ D(go, { ...l, asChild: !0, children: /* @__PURE__ */ D(
+    On,
+    {
+      ref: n,
+      sortDescriptor: p,
+      onSortChange: (h) => {
+        h && r && r({
+          column: String(h.column),
+          direction: h.direction
+        });
+      },
+      selectedKeys: a,
+      defaultSelectedKeys: c,
+      onSelectionChange: u,
+      selectionMode: i,
+      disallowEmptySelection: d,
+      disabledKeys: s,
+      disabledBehavior: "all",
+      ...l,
+      children: e
+    }
+  ) });
+});
+Ge.displayName = "DataTable.Table";
+const Bo = /* @__PURE__ */ Y(function({ footer: e, ...l }, n) {
+  return /* @__PURE__ */ ne(qe, { ref: n, ...l, children: [
+    /* @__PURE__ */ ne(Ge, { "aria-label": "Data Table", children: [
+      /* @__PURE__ */ D(Xe, { "aria-label": "Data Table Header" }),
+      /* @__PURE__ */ D(Le, { "aria-label": "Data Table Body" })
+    ] }),
+    e && /* @__PURE__ */ D(Ye, { children: e })
+  ] });
+}), xr = /* @__PURE__ */ Object.assign(Bo, {
+  Root: qe,
+  Table: Ge,
+  Header: Xe,
+  Column: Se,
+  Body: Le,
+  Row: Ue,
+  Cell: de,
+  Footer: Ye,
+  ExpandButton: cl,
+  DetailsButton: $o,
+  NestedIcon: xo,
+  SelectionCell: yo,
+  Context: Be,
+  useDataTableContext: me
+});
+export {
+  xr as D,
+  qe as a,
+  Ge as b,
+  Xe as c,
+  Se as d,
+  Le as e,
+  Ue as f,
+  de as g,
+  Ye as h,
+  cl as i,
+  $o as j,
+  xo as k,
+  yo as l,
+  Ro as u
+};
+//# sourceMappingURL=data-table-CSWloD1b.es.js.map