@commercetools/nimbus 0.0.0-canary-20260127154408 → 0.0.0-canary-20260128081211

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

@@ -0,0 +1,4546 @@
+import { jsx as x, jsxs as A, Fragment as Ae } from "react/jsx-runtime";
+import D, { useRef as P, useCallback as M, useState as G, useMemo as K, useEffect as ce, useContext as z, forwardRef as Y, createContext as fe } from "react";
+import { createSlotRecipeContext as Ql, mergeRefs as Te } from "@chakra-ui/react";
+import { n as ze, u as ie } from "./normalize-messages-BN9BAFXe.es.js";
+import { ArrowDownward as _l, KeyboardArrowDown as en, KeyboardArrowRight as tn, PushPin as ln, VisibilityOff as nn, Visibility as on, Refresh as rn, WrapText as an, ShortText as sn, DensitySmall as un, FormatAlignJustify as dn, Settings as cn, ViewWeek as fn, ViewDay as mn } from "@commercetools/nimbus-icons";
+import { S as Ce } from "./simple-grid-DU5v66TG.es.js";
+import { S as pn } from "./search-input-s4WDQ4Fd.es.js";
+import { $ as hn, D as Ie } from "./draggable-list-C02rW85A.es.js";
+import { S as Ve } from "./stack-CoNreM7B.es.js";
+import { B as oe } from "./box-DuBoAZvq.es.js";
+import { T as Re } from "./text-iTgAZrNO.es.js";
+import { S as Ft } from "./separator-DNM6keEg.es.js";
+import { B as bn } from "./button-CqHIGpN1.es.js";
+import { I as He } from "./icon-toggle-button-e9nPBYbQ.es.js";
+import { T as St } from "./toolbar-Dd6Db9sH.es.js";
+import { T as Et } from "./toggle-button-group-Q15h-2Qy.es.js";
+import { D as ye } from "./drawer-CsrMI_eY.es.js";
+import { T as gn } from "./tabs-8CdyaTFR.es.js";
+import { T as Le } from "./tooltip-C3517xYv.es.js";
+import { I as It } from "./icon-button-YqGrVmHT.es.js";
+import { $ as Q } from "./useObjectRef-CaJ5pgjX.es.js";
+import { $ as Vt } from "./Button-C9AKe3Kt.es.js";
+import { a as Ht, b as kt, c as vn } from "./RSPContexts-DLgb84PF.es.js";
+import { a as me, e as Ue, g as zt, $ as Wt, d as yn } from "./utils-CrjF8U_E.es.js";
+import { f as L, m as de, n as ue, o as We, e as $n, g as Lt, $ as Ot, b as xn, a as Cn, h as I, j as jt } from "./SelectionManager-GNsyMc-q.es.js";
+import { e as Se, g as wn, f as Dn, h as Sn, i as Ji } from "./ListBox-Bp_3E18l.es.js";
+import { $ as En } from "./intlStrings-Cd44R5hT.es.js";
+import { a as kn, $ as zn } from "./SelectionIndicator-B27AsfqE.es.js";
+import { c as nt, $ as Ut, i as An, g as Pe, f as Rn, j as Tn, a as Ge, k as Pn, h as tr } from "./CollectionBuilder-CTjJUDzO.es.js";
+import { b as Qe, a as ot, $ as j, d as Bn } from "./mergeProps-B-cqsBhL.es.js";
+import { $ as te } from "./filterDOMProps-Cxz9cAAv.es.js";
+import { a as Kn } from "./OverlayArrow-DQTbb80n.es.js";
+import { c as $e, a as it, $ as Mn } from "./scrollIntoView-Btu7DgIo.es.js";
+import { b as ar } from "./useListState-BxWOm_-s.es.js";
+import Nn from "react-dom";
+import { $ as Fn, f as In } from "./useFocusVisible-_CKiSck5.es.js";
+import { $ as ee } from "./focusSafely-hLKtxoJI.es.js";
+import { a as At, b as Vn } from "./FocusScope-DI1zU4s2.es.js";
+import { $ as xe } from "./getScrollParent-vifdmp1X.es.js";
+import { $ as Ee } from "./context-BfHy4NgG.es.js";
+import { $ as De } from "./useFocusRing-CZQUsztf.es.js";
+import { $ as Be } from "./useHover-BiPYlZr_.es.js";
+import { $ as Rt, k as Hn } from "./openLink-m90p5mer.es.js";
+import { a as Wn, b as Ln, $ as Gt } from "./usePress-UxAvyvOO.es.js";
+import { $ as On, c as jn } from "./useFocusable-C4Re42UX.es.js";
+import { $ as Ke } from "./useLocalizedStringFormatter-CYDf7GZk.es.js";
+import { $ as Un } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { $ as _e } from "./useEffectEvent-B4Fd4l1o.es.js";
+import { a as Ye, $ as Tt } from "./VisuallyHidden-BW_C1pFq.es.js";
+import { m as Oe } from "./utils-V7nfNEif.es.js";
+import { e as Gn, c as Yn } from "./Header-BQ99pNEi.es.js";
+import { $ as Xn } from "./LiveAnnouncer-CsPyaceH.es.js";
+import { d as qn, e as Zn } from "./useGridListItem-CZn3RZIy.es.js";
+import { $ as Yt } from "./useCollator-DKdD8vEj.es.js";
+import { $ as Jn } from "./useHasTabbableChild-BKDz3bMI.es.js";
+import { $ as Qn } from "./useUpdateEffect-CxkSZ4PM.es.js";
+import { e as ke } from "./extract-style-props-Cgg8HsH7.es.js";
+import { Highlight as _n } from "@chakra-ui/react/highlight";
+import { C as Xt } from "./checkbox-BUxiJPh3.es.js";
+import { F as eo } from "./flex-BqxAMF-7.es.js";
+function to(t) {
+  let { onMoveStart: e, onMove: l, onMoveEnd: n } = t, o = P({
+    didMove: !1,
+    lastPosition: null,
+    id: null
+  }), { addGlobalListener: i, removeGlobalListener: r } = Un(), d = M((m, h, g, b) => {
+    g === 0 && b === 0 || (o.current.didMove || (o.current.didMove = !0, e?.({
+      type: "movestart",
+      pointerType: h,
+      shiftKey: m.shiftKey,
+      metaKey: m.metaKey,
+      ctrlKey: m.ctrlKey,
+      altKey: m.altKey
+    })), l?.({
+      type: "move",
+      pointerType: h,
+      deltaX: g,
+      deltaY: b,
+      shiftKey: m.shiftKey,
+      metaKey: m.metaKey,
+      ctrlKey: m.ctrlKey,
+      altKey: m.altKey
+    }));
+  }, [
+    e,
+    l,
+    o
+  ]), s = _e(d), u = M((m, h) => {
+    Wn(), o.current.didMove && n?.({
+      type: "moveend",
+      pointerType: h,
+      shiftKey: m.shiftKey,
+      metaKey: m.metaKey,
+      ctrlKey: m.ctrlKey,
+      altKey: m.altKey
+    });
+  }, [
+    n,
+    o
+  ]), f = _e(u), [a, p] = G(null);
+  return Qe(() => {
+    if (a === "pointer") {
+      let m = (g) => {
+        if (g.pointerId === o.current.id) {
+          var b, y;
+          let $ = g.pointerType || "mouse";
+          var v, C;
+          s(g, $, g.pageX - ((v = (b = o.current.lastPosition) === null || b === void 0 ? void 0 : b.pageX) !== null && v !== void 0 ? v : 0), g.pageY - ((C = (y = o.current.lastPosition) === null || y === void 0 ? void 0 : y.pageY) !== null && C !== void 0 ? C : 0)), o.current.lastPosition = {
+            pageX: g.pageX,
+            pageY: g.pageY
+          };
+        }
+      }, h = (g) => {
+        if (g.pointerId === o.current.id) {
+          let b = g.pointerType || "mouse";
+          f(g, b), o.current.id = null, r(window, "pointermove", m, !1), r(window, "pointerup", h, !1), r(window, "pointercancel", h, !1), p(null);
+        }
+      };
+      return i(window, "pointermove", m, !1), i(window, "pointerup", h, !1), i(window, "pointercancel", h, !1), () => {
+        r(window, "pointermove", m, !1), r(window, "pointerup", h, !1), r(window, "pointercancel", h, !1);
+      };
+    } else if (a === "mouse" && process.env.NODE_ENV === "test") {
+      let m = (g) => {
+        if (g.button === 0) {
+          var b, y, v, C;
+          s(g, "mouse", g.pageX - ((v = (b = o.current.lastPosition) === null || b === void 0 ? void 0 : b.pageX) !== null && v !== void 0 ? v : 0), g.pageY - ((C = (y = o.current.lastPosition) === null || y === void 0 ? void 0 : y.pageY) !== null && C !== void 0 ? C : 0)), o.current.lastPosition = {
+            pageX: g.pageX,
+            pageY: g.pageY
+          };
+        }
+      }, h = (g) => {
+        g.button === 0 && (f(g, "mouse"), r(window, "mousemove", m, !1), r(window, "mouseup", h, !1), p(null));
+      };
+      return i(window, "mousemove", m, !1), i(window, "mouseup", h, !1), () => {
+        r(window, "mousemove", m, !1), r(window, "mouseup", h, !1);
+      };
+    } else if (a === "touch" && process.env.NODE_ENV === "test") {
+      let m = (g) => {
+        let b = [
+          ...g.changedTouches
+        ].findIndex(({ identifier: S }) => S === o.current.id);
+        if (b >= 0) {
+          var y, v;
+          let { pageX: S, pageY: E } = g.changedTouches[b];
+          var C, $;
+          s(g, "touch", S - ((C = (y = o.current.lastPosition) === null || y === void 0 ? void 0 : y.pageX) !== null && C !== void 0 ? C : 0), E - (($ = (v = o.current.lastPosition) === null || v === void 0 ? void 0 : v.pageY) !== null && $ !== void 0 ? $ : 0)), o.current.lastPosition = {
+            pageX: S,
+            pageY: E
+          };
+        }
+      }, h = (g) => {
+        [
+          ...g.changedTouches
+        ].findIndex(({ identifier: y }) => y === o.current.id) >= 0 && (f(g, "touch"), o.current.id = null, r(window, "touchmove", m), r(window, "touchend", h), r(window, "touchcancel", h), p(null));
+      };
+      return i(window, "touchmove", m, !1), i(window, "touchend", h, !1), i(window, "touchcancel", h, !1), () => {
+        r(window, "touchmove", m, !1), r(window, "touchend", h, !1), r(window, "touchcancel", h, !1);
+      };
+    }
+  }, [
+    a,
+    i,
+    r
+  ]), {
+    moveProps: K(() => {
+      let m = {}, h = () => {
+        Ln(), o.current.didMove = !1;
+      };
+      typeof PointerEvent > "u" && process.env.NODE_ENV === "test" ? (m.onMouseDown = (b) => {
+        b.button === 0 && (h(), b.stopPropagation(), b.preventDefault(), o.current.lastPosition = {
+          pageX: b.pageX,
+          pageY: b.pageY
+        }, p("mouse"));
+      }, m.onTouchStart = (b) => {
+        if (b.changedTouches.length === 0 || o.current.id != null) return;
+        let { pageX: y, pageY: v, identifier: C } = b.changedTouches[0];
+        h(), b.stopPropagation(), b.preventDefault(), o.current.lastPosition = {
+          pageX: y,
+          pageY: v
+        }, o.current.id = C, p("touch");
+      }) : m.onPointerDown = (b) => {
+        b.button === 0 && o.current.id == null && (h(), b.stopPropagation(), b.preventDefault(), o.current.lastPosition = {
+          pageX: b.pageX,
+          pageY: b.pageY
+        }, o.current.id = b.pointerId, p("pointer"));
+      };
+      let g = (b, y, v) => {
+        h(), d(b, "keyboard", y, v), u(b, "keyboard");
+      };
+      return m.onKeyDown = (b) => {
+        switch (b.key) {
+          case "Left":
+          case "ArrowLeft":
+            b.preventDefault(), b.stopPropagation(), g(b, -1, 0);
+            break;
+          case "Right":
+          case "ArrowRight":
+            b.preventDefault(), b.stopPropagation(), g(b, 1, 0);
+            break;
+          case "Up":
+          case "ArrowUp":
+            b.preventDefault(), b.stopPropagation(), g(b, 0, -1);
+            break;
+          case "Down":
+          case "ArrowDown":
+            b.preventDefault(), b.stopPropagation(), g(b, 0, 1);
+            break;
+        }
+      }, m;
+    }, [
+      o,
+      d,
+      u
+    ])
+  };
+}
+class qt {
+  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 d of L(n, this.collection)) {
+      var i;
+      if (d.colSpan && d.colSpan + o > l) return (i = d.key) !== null && i !== void 0 ? i : null;
+      d.colSpan && (o = o + d.colSpan - 1);
+      var r;
+      if (o === l) return (r = d.key) !== null && r !== void 0 ? r : 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, (i) => i.type === "item"), l != null) {
+      if (this.isCell(n)) {
+        let i = n.colIndex ? n.colIndex : n.index;
+        return this.getKeyForItemInRowByIndex(l, i);
+      }
+      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, (i) => i.type === "item"), l != null) {
+      if (this.isCell(n)) {
+        let i = n.colIndex ? n.colIndex : n.index;
+        return this.getKeyForItemInRowByIndex(l, i);
+      }
+      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 f = L(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = de(f)) === null || n === void 0 ? void 0 : n.key : (o = ue(f)) === null || o === void 0 ? void 0 : o.key) !== null && i !== void 0 ? i : null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let f = this.collection.getItem(l.parentKey);
+      if (!f) return null;
+      let a = L(f, this.collection);
+      var r;
+      let p = (r = this.direction === "rtl" ? We(a, l.index - 1) : We(a, l.index + 1)) !== null && r !== void 0 ? r : null;
+      var d;
+      if (p) return (d = p.key) !== null && d !== void 0 ? d : null;
+      var s;
+      if (this.focusMode === "row") return (s = l.parentKey) !== null && s !== void 0 ? s : null;
+      var u;
+      return (u = this.direction === "rtl" ? this.getFirstKey(e) : this.getLastKey(e)) !== null && u !== void 0 ? u : null;
+    }
+    return null;
+  }
+  getKeyLeftOf(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (this.isRow(l)) {
+      var n, o;
+      let f = L(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = ue(f)) === null || n === void 0 ? void 0 : n.key : (o = de(f)) === null || o === void 0 ? void 0 : o.key) !== null && i !== void 0 ? i : null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let f = this.collection.getItem(l.parentKey);
+      if (!f) return null;
+      let a = L(f, this.collection);
+      var r;
+      let p = (r = this.direction === "rtl" ? We(a, l.index + 1) : We(a, l.index - 1)) !== null && r !== void 0 ? r : null;
+      var d;
+      if (p) return (d = p.key) !== null && d !== void 0 ? d : null;
+      var s;
+      if (this.focusMode === "row") return (s = l.parentKey) !== null && s !== void 0 ? s : null;
+      var u;
+      return (u = this.direction === "rtl" ? this.getLastKey(e) : this.getFirstKey(e)) !== null && u !== void 0 ? u : 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 i;
+        let u = this.collection.getItem(o.parentKey);
+        if (!u) return null;
+        var r;
+        return (r = (i = ue(L(u, this.collection))) === null || i === void 0 ? void 0 : i.key) !== null && r !== void 0 ? r : null;
+      }
+    }
+    if (n = this.findNextKey(void 0, (u) => u.type === "item"), n != null && (o && this.isCell(o) && l || this.focusMode === "cell")) {
+      var d;
+      let u = this.collection.getItem(n);
+      if (!u) return null;
+      var s;
+      n = (s = (d = ue(L(u, this.collection))) === null || d === void 0 ? void 0 : d.key) !== null && s !== void 0 ? s : 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 i;
+        let u = this.collection.getItem(o.parentKey);
+        if (!u) return null;
+        let f = L(u, this.collection);
+        var r;
+        return (r = (i = de(f)) === null || i === void 0 ? void 0 : i.key) !== null && r !== void 0 ? r : null;
+      }
+    }
+    if (n = this.findPreviousKey(void 0, (u) => u.type === "item"), n != null && (o && this.isCell(o) && l || this.focusMode === "cell")) {
+      var d;
+      let u = this.collection.getItem(n);
+      if (!u) return null;
+      let f = L(u, this.collection);
+      var s;
+      n = (s = (d = de(f)) === null || d === void 0 ? void 0 : d.key) !== null && s !== void 0 ? s : 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 i;
+      if (l = (i = this.getKeyAbove(l)) !== null && i !== void 0 ? i : 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, i = Math.min(this.layoutDelegate.getContentSize().height, n.y + o);
+    for (; n && n.y + n.height < i; ) {
+      let r = this.getKeyBelow(l);
+      if (r == null) break;
+      n = this.layoutDelegate.getItemRect(r), l = r;
+    }
+    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 i = o.getItem(n);
+    if (!i) return null;
+    var r;
+    i.type === "cell" && (n = (r = i.parentKey) !== null && r !== void 0 ? r : null);
+    let d = !1;
+    for (; n != null; ) {
+      let f = o.getItem(n);
+      if (!f) return null;
+      if (f.textValue) {
+        let a = f.textValue.slice(0, e.length);
+        if (this.collator.compare(a, e) === 0) {
+          var s, u;
+          return this.isRow(f) && this.focusMode === "cell" ? (u = (s = ue(L(f, this.collection))) === null || s === void 0 ? void 0 : s.key) !== null && u !== void 0 ? u : null : f.key;
+        }
+      }
+      n = this.findNextKey(n, (a) => a.type === "item"), n == null && !d && (n = this.getFirstKey(), d = !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 lo(e.layout) : new Gn(e.ref));
+    var l;
+    this.focusMode = (l = e.focusMode) !== null && l !== void 0 ? l : "row";
+  }
+}
+class lo {
+  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 rt = /* @__PURE__ */ new WeakMap();
+function no(t, e, l) {
+  let { isVirtualized: n, disallowTypeAhead: o, keyboardDelegate: i, focusMode: r, scrollRef: d, getRowText: s, onRowAction: u, onCellAction: f, escapeKeyBehavior: a = "clearSelection", shouldSelectOnPressUp: p } = t, { selectionManager: c } = e;
+  !t["aria-label"] && !t["aria-labelledby"] && console.warn("An aria-label or aria-labelledby prop is required for accessibility.");
+  let m = Yt({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: h } = Ee(), g = e.selectionManager.disabledBehavior, b = K(() => i || new qt({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: g,
+    ref: l,
+    direction: h,
+    collator: m,
+    focusMode: r
+  }), [
+    i,
+    e.collection,
+    e.disabledKeys,
+    g,
+    l,
+    h,
+    m,
+    r
+  ]), { collectionProps: y } = $n({
+    ref: l,
+    selectionManager: c,
+    keyboardDelegate: b,
+    isVirtualized: n,
+    scrollRef: d,
+    disallowTypeAhead: o,
+    escapeKeyBehavior: a
+  }), v = ot(t.id);
+  rt.set(e, {
+    keyboardDelegate: b,
+    actions: {
+      onRowAction: u,
+      onCellAction: f
+    },
+    shouldSelectOnPressUp: p
+  });
+  let C = qn({
+    selectionManager: c,
+    hasItemActions: !!(u || f)
+  }), $ = te(t, {
+    labelable: !0
+  }), S = M((k) => {
+    if (c.isFocused) {
+      k.currentTarget.contains(k.target) || c.setFocused(!1);
+      return;
+    }
+    k.currentTarget.contains(k.target) && c.setFocused(!0);
+  }, [
+    c
+  ]), E = K(() => ({
+    onBlur: y.onBlur,
+    onFocus: S
+  }), [
+    S,
+    y.onBlur
+  ]), B = Jn(l, {
+    isDisabled: e.collection.size !== 0
+  }), R = j(
+    $,
+    {
+      role: "grid",
+      id: v,
+      "aria-multiselectable": c.selectionMode === "multiple" ? "true" : void 0
+    },
+    e.isKeyboardNavigationDisabled ? E : y,
+    // If collection is empty, make sure the grid is tabbable unless there is a child tabbable element.
+    e.collection.size === 0 && {
+      tabIndex: B ? -1 : 0
+    } || void 0,
+    C
+  );
+  return n && (R["aria-rowcount"] = e.collection.size, R["aria-colcount"] = e.collection.columnCount), Zn({
+    getRowText: s
+  }, e), {
+    gridProps: R
+  };
+}
+function oo() {
+  return {
+    rowGroupProps: {
+      role: "rowgroup"
+    }
+  };
+}
+function io(t, e, l) {
+  var n, o;
+  let { node: i, isVirtualized: r, shouldSelectOnPressUp: d, onAction: s } = t, { actions: u, shouldSelectOnPressUp: f } = rt.get(e), a = u.onRowAction ? () => {
+    var g;
+    return (g = u.onRowAction) === null || g === void 0 ? void 0 : g.call(u, i.key);
+  } : s, { itemProps: p, ...c } = Lt({
+    selectionManager: e.selectionManager,
+    key: i.key,
+    ref: l,
+    isVirtualized: r,
+    shouldSelectOnPressUp: f || d,
+    onAction: a || !(i == null || (n = i.props) === null || n === void 0) && n.onAction ? Bn(i == null || (o = i.props) === null || o === void 0 ? void 0 : o.onAction, a) : void 0,
+    isDisabled: e.collection.size === 0
+  }), m = e.selectionManager.isSelected(i.key), h = {
+    role: "row",
+    "aria-selected": e.selectionManager.selectionMode !== "none" ? m : void 0,
+    "aria-disabled": c.isDisabled || void 0,
+    ...p
+  };
+  return r && (h["aria-rowindex"] = i.index + 1), {
+    rowProps: h,
+    ...c
+  };
+}
+function Zt(t, e, l) {
+  let { node: n, isVirtualized: o, focusMode: i = "child", shouldSelectOnPressUp: r, onAction: d } = t, { direction: s } = Ee(), { keyboardDelegate: u, actions: { onCellAction: f } } = rt.get(e), a = P(null), p = () => {
+    if (l.current) {
+      let v = At(l.current);
+      if (i === "child") {
+        if (l.current.contains(document.activeElement) && l.current !== document.activeElement) return;
+        let C = e.selectionManager.childFocusStrategy === "last" ? Je(v) : v.firstChild();
+        if (C) {
+          ee(C);
+          return;
+        }
+      }
+      (a.current != null && n.key !== a.current || !l.current.contains(document.activeElement)) && ee(l.current);
+    }
+  }, { itemProps: c, isPressed: m } = Lt({
+    selectionManager: e.selectionManager,
+    key: n.key,
+    ref: l,
+    isVirtualized: o,
+    focus: p,
+    shouldSelectOnPressUp: r,
+    onAction: f ? () => f(n.key) : d,
+    isDisabled: e.collection.size === 0
+  }), h = (v) => {
+    if (!v.currentTarget.contains(v.target) || e.isKeyboardNavigationDisabled || !l.current || !document.activeElement) return;
+    let C = At(l.current);
+    switch (C.currentNode = document.activeElement, v.key) {
+      case "ArrowLeft": {
+        let k = s === "rtl" ? C.nextNode() : C.previousNode();
+        if (i === "child" && k === l.current && (k = null), v.preventDefault(), v.stopPropagation(), k)
+          ee(k), $e(k, {
+            containingElement: xe(l.current)
+          });
+        else {
+          var $;
+          if ((($ = u.getKeyLeftOf) === null || $ === void 0 ? void 0 : $.call(u, n.key)) !== n.key) {
+            var S;
+            (S = l.current.parentElement) === null || S === void 0 || S.dispatchEvent(new KeyboardEvent(v.nativeEvent.type, v.nativeEvent));
+            break;
+          }
+          i === "cell" && s === "rtl" ? (ee(l.current), $e(l.current, {
+            containingElement: xe(l.current)
+          })) : (C.currentNode = l.current, k = s === "rtl" ? C.firstChild() : Je(C), k && (ee(k), $e(k, {
+            containingElement: xe(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowRight": {
+        let k = s === "rtl" ? C.previousNode() : C.nextNode();
+        if (i === "child" && k === l.current && (k = null), v.preventDefault(), v.stopPropagation(), k)
+          ee(k), $e(k, {
+            containingElement: xe(l.current)
+          });
+        else {
+          var E;
+          if (((E = u.getKeyRightOf) === null || E === void 0 ? void 0 : E.call(u, n.key)) !== n.key) {
+            var B;
+            (B = l.current.parentElement) === null || B === void 0 || B.dispatchEvent(new KeyboardEvent(v.nativeEvent.type, v.nativeEvent));
+            break;
+          }
+          i === "cell" && s === "ltr" ? (ee(l.current), $e(l.current, {
+            containingElement: xe(l.current)
+          })) : (C.currentNode = l.current, k = s === "rtl" ? Je(C) : C.firstChild(), k && (ee(k), $e(k, {
+            containingElement: xe(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowUp":
+      case "ArrowDown":
+        if (!v.altKey && l.current.contains(v.target)) {
+          var R;
+          v.stopPropagation(), v.preventDefault(), (R = l.current.parentElement) === null || R === void 0 || R.dispatchEvent(new KeyboardEvent(v.nativeEvent.type, v.nativeEvent));
+        }
+        break;
+    }
+  }, g = (v) => {
+    if (a.current = n.key, v.target !== l.current) {
+      Fn() || e.selectionManager.setFocusedKey(n.key);
+      return;
+    }
+    requestAnimationFrame(() => {
+      i === "child" && document.activeElement === l.current && p();
+    });
+  }, b = j(c, {
+    role: "gridcell",
+    onKeyDownCapture: h,
+    "aria-colspan": n.colSpan,
+    "aria-colindex": n.colIndex != null ? n.colIndex + 1 : void 0,
+    colSpan: o ? void 0 : n.colSpan,
+    onFocus: g
+  });
+  var y;
+  return o && (b["aria-colindex"] = ((y = n.colIndex) !== null && y !== void 0 ? y : n.index) + 1), r && b.tabIndex != null && b.onPointerDown == null && (b.onPointerDown = (v) => {
+    let C = v.currentTarget, $ = C.getAttribute("tabindex");
+    C.removeAttribute("tabindex"), requestAnimationFrame(() => {
+      $ != null && C.setAttribute("tabindex", $);
+    });
+  }), {
+    gridCellProps: b,
+    isPressed: m
+  };
+}
+function Je(t) {
+  let e = null, l = null;
+  do
+    l = t.lastChild(), l && (e = l);
+  while (l);
+  return e;
+}
+const at = /* @__PURE__ */ new WeakMap();
+function et(t) {
+  return typeof t == "string" ? t.replace(/\s*/g, "") : "" + t;
+}
+function Jt(t, e) {
+  let l = at.get(t);
+  if (!l) throw new Error("Unknown grid");
+  return `${l}-${et(e)}`;
+}
+function Qt(t, e, l) {
+  let n = at.get(t);
+  if (!n) throw new Error("Unknown grid");
+  return `${n}-${et(e)}-${et(l)}`;
+}
+function _t(t, e) {
+  return [
+    ...t.collection.rowHeaderColumnKeys
+  ].map((l) => Qt(t, e, l)).join(" ");
+}
+var el = {};
+el = {
+  ascending: "تصاعدي",
+  ascendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تصاعدي`,
+  columnSize: (t) => `${t.value} بالبكسل`,
+  descending: "تنازلي",
+  descendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تنازلي`,
+  resizerDescription: "اضغط على مفتاح Enter لبدء تغيير الحجم",
+  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 ll = {};
+ll = {
+  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 nl = {};
+nl = {
+  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 ol = {};
+ol = {
+  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 il = {};
+il = {
+  ascending: "αύξουσα",
+  ascendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε αύξουσα σειρά`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "φθίνουσα",
+  descendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε φθίνουσα σειρά`,
+  resizerDescription: "Πατήστε Enter για έναρξη της αλλαγής μεγέθους",
+  select: "Επιλογή",
+  selectAll: "Επιλογή όλων",
+  sortable: "Στήλη διαλογής"
+};
+var rl = {};
+rl = {
+  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 al = {};
+al = {
+  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 sl = {};
+sl = {
+  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 ul = {};
+ul = {
+  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 dl = {};
+dl = {
+  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 cl = {};
+cl = {
+  ascending: "עולה",
+  ascendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר עולה`,
+  columnSize: (t) => `${t.value} פיקסלים`,
+  descending: "יורד",
+  descendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר יורד`,
+  resizerDescription: "הקש Enter כדי לשנות את הגודל",
+  select: "בחר",
+  selectAll: "בחר הכול",
+  sortable: "עמודה שניתן למיין"
+};
+var fl = {};
+fl = {
+  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 ml = {};
+ml = {
+  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 pl = {};
+pl = {
+  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 hl = {};
+hl = {
+  ascending: "昇順",
+  ascendingSort: (t) => `列 ${t.columnName} を昇順で並べ替え`,
+  columnSize: (t) => `${t.value} ピクセル`,
+  descending: "降順",
+  descendingSort: (t) => `列 ${t.columnName} を降順で並べ替え`,
+  resizerDescription: "Enter キーを押してサイズ変更を開始",
+  select: "選択",
+  selectAll: "すべて選択",
+  sortable: "並べ替え可能な列"
+};
+var bl = {};
+bl = {
+  ascending: "오름차순",
+  ascendingSort: (t) => `${t.columnName} 열을 기준으로 오름차순으로 정렬됨`,
+  columnSize: (t) => `${t.value} 픽셀`,
+  descending: "내림차순",
+  descendingSort: (t) => `${t.columnName} 열을 기준으로 내림차순으로 정렬됨`,
+  resizerDescription: "크기 조정을 시작하려면 Enter를 누르세요.",
+  select: "선택",
+  selectAll: "모두 선택",
+  sortable: "정렬 가능한 열"
+};
+var gl = {};
+gl = {
+  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 vl = {};
+vl = {
+  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 yl = {};
+yl = {
+  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 $l = {};
+$l = {
+  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 xl = {};
+xl = {
+  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 Cl = {};
+Cl = {
+  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 wl = {};
+wl = {
+  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 Dl = {};
+Dl = {
+  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 Sl = {};
+Sl = {
+  ascending: "возрастание",
+  ascendingSort: (t) => `сортировать столбец ${t.columnName} в порядке возрастания`,
+  columnSize: (t) => `${t.value} пикс.`,
+  descending: "убывание",
+  descendingSort: (t) => `сортировать столбец ${t.columnName} в порядке убывания`,
+  resizerDescription: "Нажмите клавишу Enter для начала изменения размеров",
+  select: "Выбрать",
+  selectAll: "Выбрать все",
+  sortable: "сортируемый столбец"
+};
+var El = {};
+El = {
+  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 kl = {};
+kl = {
+  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 zl = {};
+zl = {
+  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 Al = {};
+Al = {
+  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 Rl = {};
+Rl = {
+  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 Tl = {};
+Tl = {
+  ascending: "висхідний",
+  ascendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у висхідному порядку`,
+  columnSize: (t) => `${t.value} пікс.`,
+  descending: "низхідний",
+  descendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у низхідному порядку`,
+  resizerDescription: "Натисніть Enter, щоб почати зміну розміру",
+  select: "Вибрати",
+  selectAll: "Вибрати все",
+  sortable: "сортувальний стовпець"
+};
+var Pl = {};
+Pl = {
+  ascending: "升序",
+  ascendingSort: (t) => `按列 ${t.columnName} 升序排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "降序",
+  descendingSort: (t) => `按列 ${t.columnName} 降序排序`,
+  resizerDescription: "按“输入”键开始调整大小。",
+  select: "选择",
+  selectAll: "全选",
+  sortable: "可排序的列"
+};
+var Bl = {};
+Bl = {
+  ascending: "遞增",
+  ascendingSort: (t) => `已依據「${t.columnName}」欄遞增排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "遞減",
+  descendingSort: (t) => `已依據「${t.columnName}」欄遞減排序`,
+  resizerDescription: "按 Enter 鍵以開始調整大小",
+  select: "選取",
+  selectAll: "全選",
+  sortable: "可排序的欄"
+};
+var Me = {};
+Me = {
+  "ar-AE": el,
+  "bg-BG": tl,
+  "cs-CZ": ll,
+  "da-DK": nl,
+  "de-DE": ol,
+  "el-GR": il,
+  "en-US": rl,
+  "es-ES": al,
+  "et-EE": sl,
+  "fi-FI": ul,
+  "fr-FR": dl,
+  "he-IL": cl,
+  "hr-HR": fl,
+  "hu-HU": ml,
+  "it-IT": pl,
+  "ja-JP": hl,
+  "ko-KR": bl,
+  "lt-LT": gl,
+  "lv-LV": vl,
+  "nb-NO": yl,
+  "nl-NL": $l,
+  "pl-PL": xl,
+  "pt-BR": Cl,
+  "pt-PT": wl,
+  "ro-RO": Dl,
+  "ru-RU": Sl,
+  "sk-SK": El,
+  "sl-SI": kl,
+  "sr-SP": zl,
+  "sv-SE": Al,
+  "tr-TR": Rl,
+  "uk-UA": Tl,
+  "zh-CN": Pl,
+  "zh-TW": Bl
+};
+class ro extends qt {
+  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 = ue(L(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 i = l.parentKey != null ? this.collection.getItem(l.parentKey) : null;
+      return i && i.type === "column" ? i.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 L(n, this.collection))
+      if (o.type === "column") return o.key;
+    return null;
+  }
+  findPreviousColumnKey(e) {
+    let l = this.findPreviousKey(e.key, (i) => i.type === "column");
+    if (l != null) return l;
+    let n = this.collection.headerRows[e.level], o = [
+      ...L(n, this.collection)
+    ];
+    for (let i = o.length - 1; i >= 0; i--) {
+      let r = o[i];
+      if (r.type === "column") return r.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 i = n.getItem(o);
+    var r;
+    i?.type === "cell" && (o = (r = i.parentKey) !== null && r !== void 0 ? r : null);
+    let d = !1;
+    for (; o != null; ) {
+      let s = n.getItem(o);
+      if (!s) return null;
+      if (s.textValue) {
+        let u = s.textValue.slice(0, e.length);
+        if (this.collator.compare(u, e) === 0) return s.key;
+      }
+      for (let u of L(s, this.collection)) {
+        let f = n.columns[u.index];
+        if (n.rowHeaderColumnKeys.has(f.key) && u.textValue) {
+          let a = u.textValue.slice(0, e.length);
+          if (this.collator.compare(a, e) === 0) {
+            let p = l != null ? n.getItem(l) : i;
+            return p?.type === "cell" ? u.key : s.key;
+          }
+        }
+      }
+      o = this.getKeyBelow(o), o == null && !d && (o = this.getFirstKey(), d = !0);
+    }
+    return null;
+  }
+}
+function ao(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function so(t, e, l) {
+  let { keyboardDelegate: n, isVirtualized: o, layoutDelegate: i, layout: r } = t, d = Yt({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: s } = Ee(), u = e.selectionManager.disabledBehavior, f = K(() => n || new ro({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: u,
+    ref: l,
+    direction: s,
+    collator: d,
+    layoutDelegate: i,
+    layout: r
+  }), [
+    n,
+    e.collection,
+    e.disabledKeys,
+    u,
+    l,
+    s,
+    d,
+    i,
+    r
+  ]), a = ot(t.id);
+  at.set(e, a);
+  let { gridProps: p } = no({
+    ...t,
+    id: a,
+    keyboardDelegate: f
+  }, e, l);
+  o && (p["aria-rowcount"] = e.collection.size + e.collection.headerRows.length), Oe() && "expandedKeys" in e && (p.role = "treegrid");
+  let { column: c, direction: m } = e.sortDescriptor || {}, h = Ke(ao(Me), "@react-aria/table"), g = K(() => {
+    var y, v;
+    let C = (v = (y = e.collection.columns.find(($) => $.key === c)) === null || y === void 0 ? void 0 : y.textValue) !== null && v !== void 0 ? v : "";
+    return m && c ? h.format(`${m}Sort`, {
+      columnName: C
+    }) : void 0;
+  }, [
+    m,
+    c,
+    e.collection.columns
+  ]), b = it(g);
+  return Qn(() => {
+    g && Xn(g, "assertive", 500);
+  }, [
+    g
+  ]), {
+    gridProps: j(p, b, {
+      // merge sort description with long press information
+      "aria-describedby": [
+        b["aria-describedby"],
+        p["aria-describedby"]
+      ].filter(Boolean).join(" ")
+    })
+  };
+}
+function uo(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function co(t, e, l) {
+  var n, o;
+  let { node: i } = t, r = i.props.allowsSorting, { gridCellProps: d } = Zt({
+    ...t,
+    focusMode: "child"
+  }, e, l), s = i.props.isSelectionCell && e.selectionManager.selectionMode === "single", { pressProps: u, isPressed: f } = Gt({
+    isDisabled: !r || s,
+    onPress() {
+      e.sort(i.key);
+    },
+    ref: l
+  }), { focusableProps: a } = On({}, l), p, c = ((n = e.sortDescriptor) === null || n === void 0 ? void 0 : n.column) === i.key, m = (o = e.sortDescriptor) === null || o === void 0 ? void 0 : o.direction;
+  i.props.allowsSorting && !Rt() && (p = c ? m : "none");
+  let h = Ke(uo(Me), "@react-aria/table"), g;
+  r && (g = `${h.format("sortable")}`, c && m && Rt() && (g = `${g}, ${h.format(m)}`));
+  let b = it(g), y = e.collection.size === 0;
+  return ce(() => {
+    y && e.selectionManager.focusedKey === i.key && e.selectionManager.setFocusedKey(null);
+  }, [
+    y,
+    e.selectionManager,
+    i.key
+  ]), {
+    columnHeaderProps: {
+      ...j(
+        a,
+        d,
+        u,
+        b,
+        // If the table is empty, make all column headers untabbable
+        y ? {
+          tabIndex: -1
+        } : null
+      ),
+      role: "columnheader",
+      id: Jt(e, i.key),
+      "aria-colspan": i.colSpan && i.colSpan > 1 ? i.colSpan : void 0,
+      "aria-sort": p
+    },
+    isPressed: f
+  };
+}
+const Pt = {
+  expand: {
+    ltr: "ArrowRight",
+    rtl: "ArrowLeft"
+  },
+  collapse: {
+    ltr: "ArrowLeft",
+    rtl: "ArrowRight"
+  }
+};
+function fo(t, e, l) {
+  let { node: n, isVirtualized: o } = t, { rowProps: i, ...r } = io(t, e, l), { direction: d } = Ee();
+  o && !(Oe() && "expandedKeys" in e) ? i["aria-rowindex"] = n.index + 1 + e.collection.headerRows.length : delete i["aria-rowindex"];
+  let s = {};
+  if (Oe() && "expandedKeys" in e) {
+    let $ = e.keyMap.get(n.key);
+    if ($ != null) {
+      var u, f, a, p, c, m;
+      let S = ((u = $.props) === null || u === void 0 ? void 0 : u.UNSTABLE_childItems) || ((a = $.props) === null || a === void 0 || (f = a.children) === null || f === void 0 ? void 0 : f.length) > e.userColumnCount;
+      var h, g, b, y;
+      s = {
+        onKeyDown: (E) => {
+          (E.key === Pt.expand[d] && e.selectionManager.focusedKey === $.key && S && e.expandedKeys !== "all" && !e.expandedKeys.has($.key) || E.key === Pt.collapse[d] && e.selectionManager.focusedKey === $.key && S && (e.expandedKeys === "all" || e.expandedKeys.has($.key))) && (e.toggleKey($.key), E.stopPropagation());
+        },
+        "aria-expanded": S ? e.expandedKeys === "all" || e.expandedKeys.has(n.key) : void 0,
+        "aria-level": $.level,
+        "aria-posinset": ((h = $.indexOfType) !== null && h !== void 0 ? h : 0) + 1,
+        "aria-setsize": $.level > 1 ? ((b = (p = de((g = (c = e.keyMap.get($.parentKey)) === null || c === void 0 ? void 0 : c.childNodes) !== null && g !== void 0 ? g : [])) === null || p === void 0 ? void 0 : p.indexOfType) !== null && b !== void 0 ? b : 0) + 1 : ((y = (m = de(e.collection.body.childNodes)) === null || m === void 0 ? void 0 : m.indexOfType) !== null && y !== void 0 ? y : 0) + 1
+      };
+    }
+  }
+  let v = Hn(n.props), C = r.hasAction ? v : {};
+  return {
+    rowProps: {
+      ...j(i, s, C),
+      "aria-labelledby": _t(e, n.key)
+    },
+    ...r
+  };
+}
+function mo(t, e, l) {
+  let { node: n, isVirtualized: o } = t, i = {
+    role: "row"
+  };
+  return o && !(Oe() && "expandedKeys" in e) && (i["aria-rowindex"] = n.index + 1), {
+    rowProps: i
+  };
+}
+function po(t, e, l) {
+  var n;
+  let { gridCellProps: o, isPressed: i } = Zt(t, e, l), r = (n = t.node.column) === null || n === void 0 ? void 0 : n.key;
+  return r != null && e.collection.rowHeaderColumnKeys.has(r) && (o.role = "rowheader", o.id = Qt(e, t.node.parentKey, r)), {
+    gridCellProps: o,
+    isPressed: i
+  };
+}
+function ho(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function bo(t, e) {
+  let { key: l } = t;
+  const { checkboxProps: n } = hn(t, e);
+  return {
+    checkboxProps: {
+      ...n,
+      "aria-labelledby": `${n.id} ${_t(e, l)}`
+    }
+  };
+}
+function go(t) {
+  let { isEmpty: e, isSelectAll: l, selectionMode: n } = t.selectionManager;
+  return {
+    checkboxProps: {
+      "aria-label": Ke(ho(Me), "@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 vo(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function yo(t, e, l) {
+  let { column: n, triggerRef: o, isDisabled: i, onResizeStart: r, onResize: d, onResizeEnd: s, "aria-label": u } = t;
+  const f = Ke(vo(Me), "@react-aria/table");
+  let a = ot(), p = e.resizingColumn === n.key, c = P(p), m = P(null), h = P(!1), g = e.tableState.isKeyboardNavigationDisabled, { direction: b } = Ee(), y = M((w) => {
+    c.current || (m.current = e.updateResizedColumns(w.key, e.getColumnWidth(w.key)), e.startResize(w.key), e.tableState.setKeyboardNavigationDisabled(!0), r?.(m.current)), c.current = !0;
+  }, [
+    e,
+    r
+  ]), v = M((w, T) => {
+    let V = e.updateResizedColumns(w.key, T);
+    d?.(V), m.current = V;
+  }, [
+    e,
+    d
+  ]), C = M((w) => {
+    c.current && (m.current == null && (m.current = e.updateResizedColumns(w.key, e.getColumnWidth(w.key))), e.endResize(), e.tableState.setKeyboardNavigationDisabled(!1), s?.(m.current), c.current = !1, o?.current && !h.current && ee(o.current)), m.current = null;
+  }, [
+    e,
+    o,
+    s
+  ]), { keyboardProps: $ } = jn({
+    onKeyDown: (w) => {
+      g ? (w.key === "Escape" || w.key === "Enter" || w.key === " " || w.key === "Tab") && (w.preventDefault(), C(n)) : (w.continuePropagation(), w.key === "Enter" && y(n));
+    }
+  });
+  const S = P(0), { moveProps: E } = to({
+    onMoveStart() {
+      S.current = e.getColumnWidth(n.key), y(n);
+    },
+    onMove(w) {
+      let { deltaX: T, deltaY: V, pointerType: ge } = w;
+      b === "rtl" && (T *= -1), ge === "keyboard" && (V !== 0 && T === 0 && (T = V * -1), T *= 10), T !== 0 && (S.current += T, v(n, S.current));
+    },
+    onMoveEnd(w) {
+      let { pointerType: T } = w;
+      S.current = 0, (T === "mouse" || T === "touch" && h.current) && C(n);
+    }
+  });
+  let B = M((w) => {
+    var T;
+    g && ((T = E.onKeyDown) === null || T === void 0 || T.call(E, w));
+  }, [
+    g,
+    E
+  ]), R = Math.floor(e.getColumnMinWidth(n.key)), k = Math.floor(e.getColumnMaxWidth(n.key));
+  k === 1 / 0 && (k = Number.MAX_SAFE_INTEGER);
+  let N = Math.floor(e.getColumnWidth(n.key)), H = In();
+  H === "virtual" && typeof window < "u" && "ontouchstart" in window && (H = "touch");
+  let O = o?.current == null && (H === "keyboard" || H === "virtual") && !p ? f.format("resizerDescription") : void 0, W = it(O), F = {
+    "aria-label": u,
+    "aria-orientation": "horizontal",
+    "aria-labelledby": `${a} ${Jt(e.tableState, n.key)}`,
+    "aria-valuetext": f.format("columnSize", {
+      value: N
+    }),
+    type: "range",
+    min: R,
+    max: k,
+    value: N,
+    ...W
+  };
+  const X = M(() => {
+    l.current && ee(l.current);
+  }, [
+    l
+  ]);
+  let U = e.resizingColumn, le = P(null), he = _e(y);
+  ce(() => {
+    if (le.current !== U && U != null && U === n.key) {
+      h.current = document.activeElement === l.current, he(n);
+      let w = setTimeout(() => X(), 0), T = setTimeout(X, 400);
+      return () => {
+        clearTimeout(w), clearTimeout(T);
+      };
+    }
+    le.current = U;
+  }, [
+    U,
+    n,
+    X,
+    l
+  ]);
+  let ne = (w) => {
+    let T = e.getColumnWidth(n.key), V = parseFloat(w.target.value);
+    V > T ? V = T + 10 : V = T - 10, v(n, V);
+  }, { pressProps: _ } = Gt({
+    preventFocusOnPress: !0,
+    onPressStart: (w) => {
+      if (!(w.ctrlKey || w.altKey || w.metaKey || w.shiftKey || w.pointerType === "keyboard")) {
+        if (w.pointerType === "virtual" && e.resizingColumn != null) {
+          C(n);
+          return;
+        }
+        X(), w.pointerType !== "virtual" && y(n);
+      }
+    },
+    onPress: (w) => {
+      (w.pointerType === "touch" && h.current || w.pointerType === "mouse") && e.resizingColumn != null && C(n);
+    }
+  }), { visuallyHiddenProps: se } = Ye();
+  return {
+    resizerProps: j($, {
+      ...E,
+      onKeyDown: B
+    }, _, {
+      style: {
+        touchAction: "none"
+      }
+    }),
+    inputProps: j(se, {
+      id: a,
+      onBlur: () => {
+        C(n);
+      },
+      onChange: ne,
+      disabled: i
+    }, F),
+    isResizing: p
+  };
+}
+function Kl() {
+  return oo();
+}
+function $o(t) {
+  return t != null && (!isNaN(t) || String(t).match(/^(\d+)(?=%$)/) !== null);
+}
+function xo(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 st(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 Ml(t, e) {
+  return t != null ? st(t, e) : Number.MAX_SAFE_INTEGER;
+}
+function Nl(t, e) {
+  return t != null ? st(t, e) : 0;
+}
+function Co(t, e, l, n, o) {
+  let i = !1, r = e.map((d, s) => {
+    var u, f, a, p;
+    let c = l.get(d.key) != null ? (u = l.get(d.key)) !== null && u !== void 0 ? u : "1fr" : (p = (a = (f = d.width) !== null && f !== void 0 ? f : d.defaultWidth) !== null && a !== void 0 ? a : n?.(s)) !== null && p !== void 0 ? p : "1fr", m = !1, h = 0, g = 0, b = 0;
+    $o(c) ? (h = st(c, t), m = !0) : (g = xo(c), g <= 0 && (m = !0));
+    var y, v;
+    let C = Nl((v = (y = d.minWidth) !== null && y !== void 0 ? y : o?.(s)) !== null && v !== void 0 ? v : 0, t), $ = Ml(d.maxWidth, t), S = Math.max(C, Math.min(h, $));
+    return m ? b = S : h > S && (m = !0, b = S), m || (i = !0), {
+      frozen: m,
+      baseSize: h,
+      hypotheticalMainSize: S,
+      min: C,
+      max: $,
+      flex: g,
+      targetMainSize: b,
+      violation: 0
+    };
+  });
+  for (; i; ) {
+    let d = 0, s = 0;
+    r.forEach((a) => {
+      a.frozen ? d += a.targetMainSize : (d += a.baseSize, s += a.flex);
+    });
+    let u = t - d;
+    u > 0 && r.forEach((a) => {
+      if (!a.frozen) {
+        let p = a.flex / s;
+        a.targetMainSize = a.baseSize + p * u;
+      }
+    });
+    let f = 0;
+    r.forEach((a) => {
+      if (a.violation = 0, !a.frozen) {
+        let { min: p, max: c, targetMainSize: m } = a;
+        a.targetMainSize = Math.max(p, Math.min(m, c)), a.violation = a.targetMainSize - m, f += a.violation;
+      }
+    }), i = !1, r.forEach((a) => {
+      f === 0 || Math.sign(f) === Math.sign(a.violation) ? a.frozen = !0 : a.frozen || (i = !0);
+    });
+  }
+  return wo(r);
+}
+function wo(t) {
+  let e = 0, l = 0, n = [];
+  return t.forEach(function(o) {
+    let i = o.targetMainSize, r = Math.round(i + e) - l;
+    e += i, l += r, n.push(r);
+  }), n;
+}
+class Do {
+  /** 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((i) => n.has(i.key) ? [
+      i.key,
+      l.get(i.key)
+    ] : [
+      i.key,
+      o.get(i.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, i, r, d;
+      return [
+        l,
+        (d = (r = n.props.defaultWidth) !== null && r !== void 0 ? r : (o = (i = this).getDefaultWidth) === null || o === void 0 ? void 0 : o.call(i, n)) !== null && d !== void 0 ? d : "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 i = this.columnWidths, r = !0, d = /* @__PURE__ */ new Map();
+    return o = Math.max(this.getColumnMinWidth(n), Math.min(this.getColumnMaxWidth(n), Math.floor(o))), e.columns.forEach((s) => {
+      var u, f;
+      s.key === n ? (d.set(s.key, o), r = !1) : r ? d.set(s.key, (u = i.get(s.key)) !== null && u !== void 0 ? u : 0) : d.set(s.key, (f = s.props.width) !== null && f !== void 0 ? f : l.get(s.key));
+    }), d;
+  }
+  buildColumnWidths(e, l, n) {
+    return this.columnWidths = /* @__PURE__ */ new Map(), this.columnMinWidths = /* @__PURE__ */ new Map(), this.columnMaxWidths = /* @__PURE__ */ new Map(), Co(e, l.columns.map((i) => ({
+      ...i.props,
+      key: i.key
+    })), n, (i) => this.getDefaultWidth(l.columns[i]), (i) => this.getDefaultMinWidth(l.columns[i])).forEach((i, r) => {
+      let d = l.columns[r].key, s = l.columns[r];
+      this.columnWidths.set(d, i);
+      var u;
+      this.columnMinWidths.set(d, Nl((u = s.props.minWidth) !== null && u !== void 0 ? u : this.getDefaultMinWidth(s), e)), this.columnMaxWidths.set(d, Ml(s.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 So(t, e) {
+  let { getDefaultWidth: l, getDefaultMinWidth: n, tableWidth: o = 0 } = t, [i, r] = G(null), d = K(() => new Do({
+    getDefaultWidth: l,
+    getDefaultMinWidth: n
+  }), [
+    l,
+    n
+  ]), [s, u] = K(() => d.splitColumnsIntoControlledAndUncontrolled(e.collection.columns), [
+    e.collection.columns,
+    d
+  ]), [f, a] = G(() => d.getInitialUncontrolledWidths(u)), [p, c] = G(e.collection.columns);
+  if (e.collection.columns !== p) {
+    if (e.collection.columns.length !== p.length || e.collection.columns.some((v, C) => v.key !== p[C].key)) {
+      let v = d.getInitialUncontrolledWidths(u);
+      a(v);
+    }
+    c(e.collection.columns);
+  }
+  let m = K(() => d.recombineColumns(e.collection.columns, f, u, s), [
+    e.collection.columns,
+    f,
+    u,
+    s,
+    d
+  ]), h = M((v) => {
+    r(v);
+  }, [
+    r
+  ]), g = M((v, C) => {
+    let $ = d.resizeColumnWidth(e.collection, f, v, C), S = new Map(Array.from(u).map(([E]) => [
+      E,
+      $.get(E)
+    ]));
+    return S.set(v, C), a(S), $;
+  }, [
+    u,
+    a,
+    d,
+    e.collection,
+    f
+  ]), b = M(() => {
+    r(null);
+  }, [
+    r
+  ]), y = K(() => d.buildColumnWidths(o, e.collection, m), [
+    o,
+    e.collection,
+    m,
+    d
+  ]);
+  return K(() => ({
+    resizingColumn: i,
+    updateResizedColumns: g,
+    startResize: h,
+    endResize: b,
+    getColumnWidth: (v) => d.getColumnWidth(v),
+    getColumnMinWidth: (v) => d.getColumnMinWidth(v),
+    getColumnMaxWidth: (v) => d.getColumnMaxWidth(v),
+    tableState: e,
+    columnWidths: y
+  }), [
+    d,
+    y,
+    i,
+    g,
+    h,
+    b,
+    e
+  ]);
+}
+function Eo(t) {
+  let { collection: e, focusMode: l } = t, n = t.UNSAFE_selectionState || Ot(t), o = K(() => t.disabledKeys ? new Set(t.disabledKeys) : /* @__PURE__ */ new Set(), [
+    t.disabledKeys
+  ]), i = n.setFocusedKey;
+  n.setFocusedKey = (s, u) => {
+    if (l === "cell" && s != null) {
+      let m = e.getItem(s);
+      if (m?.type === "item") {
+        var f, a;
+        let h = L(m, e);
+        var p, c;
+        u === "last" ? s = (p = (f = de(h)) === null || f === void 0 ? void 0 : f.key) !== null && p !== void 0 ? p : null : s = (c = (a = ue(h)) === null || a === void 0 ? void 0 : a.key) !== null && c !== void 0 ? c : null;
+      }
+    }
+    i(s, u);
+  };
+  let r = K(() => new xn(e, n), [
+    e,
+    n
+  ]);
+  const d = P(null);
+  return ce(() => {
+    if (n.focusedKey != null && d.current && !e.getItem(n.focusedKey)) {
+      const s = d.current.getItem(n.focusedKey), u = s?.parentKey != null && (s.type === "cell" || s.type === "rowheader" || s.type === "column") ? d.current.getItem(s.parentKey) : s;
+      if (!u) {
+        n.setFocusedKey(null);
+        return;
+      }
+      const f = d.current.rows, a = e.rows, p = f.length - a.length;
+      let c = Math.min(p > 1 ? Math.max(u.index - p + 1, 0) : u.index, a.length - 1), m = null;
+      for (; c >= 0; ) {
+        if (!r.isDisabled(a[c].key) && a[c].type !== "headerrow") {
+          m = a[c];
+          break;
+        }
+        c < a.length - 1 ? c++ : (c > u.index && (c = u.index), c--);
+      }
+      if (m) {
+        const h = m.hasChildNodes ? [
+          ...L(m, e)
+        ] : [], g = m.hasChildNodes && u !== s && s && s.index < h.length ? h[s.index].key : m.key;
+        n.setFocusedKey(g);
+      } else n.setFocusedKey(null);
+    }
+    d.current = e;
+  }, [
+    e,
+    r,
+    n,
+    n.focusedKey
+  ]), {
+    collection: e,
+    disabledKeys: o,
+    isKeyboardNavigationDisabled: !1,
+    selectionManager: r
+  };
+}
+class ko {
+  *[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 = (a) => {
+      let p = this.keyMap.get(a.key);
+      e.visitNode && (a = e.visitNode(a)), this.keyMap.set(a.key, a);
+      let c = /* @__PURE__ */ new Set(), m = null, h = !1;
+      if (a.type === "item") {
+        var g;
+        for (let $ of a.childNodes) if (((g = $.props) === null || g === void 0 ? void 0 : g.colSpan) !== void 0) {
+          h = !0;
+          break;
+        }
+      }
+      for (let $ of a.childNodes) {
+        if ($.type === "cell" && h) {
+          var b, y;
+          $.colspan = (b = $.props) === null || b === void 0 ? void 0 : b.colSpan, $.colSpan = (y = $.props) === null || y === void 0 ? void 0 : y.colSpan;
+          var v, C;
+          $.colIndex = m ? ((v = m.colIndex) !== null && v !== void 0 ? v : m.index) + ((C = m.colSpan) !== null && C !== void 0 ? C : 1) : $.index;
+        }
+        $.type === "cell" && $.parentKey == null && ($.parentKey = a.key), c.add($.key), m ? (m.nextKey = $.key, $.prevKey = m.key) : $.prevKey = null, l($), m = $;
+      }
+      if (m && (m.nextKey = null), p)
+        for (let $ of p.childNodes) c.has($.key) || n($);
+    }, n = (a) => {
+      this.keyMap.delete(a.key);
+      for (let p of a.childNodes) this.keyMap.get(p.key) === p && n(p);
+    }, o = null;
+    for (let [a, p] of e.items.entries()) {
+      var i, r, d, s, u, f;
+      let c = {
+        ...p,
+        level: (i = p.level) !== null && i !== void 0 ? i : 0,
+        key: (r = p.key) !== null && r !== void 0 ? r : "row-" + a,
+        type: (d = p.type) !== null && d !== void 0 ? d : "row",
+        value: (s = p.value) !== null && s !== void 0 ? s : null,
+        hasChildNodes: !0,
+        childNodes: [
+          ...p.childNodes
+        ],
+        rendered: p.rendered,
+        textValue: (u = p.textValue) !== null && u !== void 0 ? u : "",
+        index: (f = p.index) !== null && f !== void 0 ? f : a
+      };
+      o ? (o.nextKey = c.key, c.prevKey = o.key) : c.prevKey = null, this.rows.push(c), l(c), o = c;
+    }
+    o && (o.nextKey = null);
+  }
+}
+const Fl = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+let tt = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+for (; Fl === tt; ) tt = "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 f of e) {
+    let a = f.parentKey, p = [
+      f
+    ];
+    for (; a; ) {
+      let c = t.get(a);
+      if (!c) break;
+      if (n.has(c)) {
+        var o, i;
+        (i = (o = c).colSpan) !== null && i !== void 0 || (o.colSpan = 0), c.colSpan++, c.colspan = c.colSpan;
+        let { column: m, index: h } = n.get(c);
+        if (h > p.length) break;
+        for (let g = h; g < p.length; g++) m.splice(g, 0, null);
+        for (let g = p.length; g < m.length; g++)
+          m[g] && n.has(m[g]) && (n.get(m[g]).index = g);
+      } else
+        c.colSpan = 1, c.colspan = 1, p.push(c), n.set(c, {
+          column: p,
+          index: p.length - 1
+        });
+      a = c.parentKey;
+    }
+    l.push(p), f.index = l.length - 1;
+  }
+  let r = Math.max(...l.map((f) => f.length)), d = Array(r).fill(0).map(() => []), s = 0;
+  for (let f of l) {
+    let a = r - 1;
+    for (let p of f) {
+      if (p) {
+        let c = d[a], m = c.reduce((h, g) => {
+          var b;
+          return h + ((b = g.colSpan) !== null && b !== void 0 ? b : 1);
+        }, 0);
+        if (m < s) {
+          let h = {
+            type: "placeholder",
+            key: "placeholder-" + p.key,
+            colspan: s - m,
+            colSpan: s - m,
+            index: m,
+            value: null,
+            rendered: null,
+            level: a,
+            hasChildNodes: !1,
+            childNodes: [],
+            textValue: ""
+          };
+          c.length > 0 && (c[c.length - 1].nextKey = h.key, h.prevKey = c[c.length - 1].key), c.push(h);
+        }
+        c.length > 0 && (c[c.length - 1].nextKey = p.key, p.prevKey = c[c.length - 1].key), p.level = a, p.colIndex = s, c.push(p);
+      }
+      a--;
+    }
+    s++;
+  }
+  let u = 0;
+  for (let f of d) {
+    let a = f.reduce((p, c) => {
+      var m;
+      return p + ((m = c.colSpan) !== null && m !== void 0 ? m : 1);
+    }, 0);
+    if (a < e.length) {
+      let p = {
+        type: "placeholder",
+        key: "placeholder-" + f[f.length - 1].key,
+        colSpan: e.length - a,
+        colspan: e.length - a,
+        index: a,
+        value: null,
+        rendered: null,
+        level: u,
+        hasChildNodes: !1,
+        childNodes: [],
+        textValue: "",
+        prevKey: f[f.length - 1].key
+      };
+      f.push(p);
+    }
+    u++;
+  }
+  return d.map((f, a) => ({
+    type: "headerrow",
+    key: "headerrow-" + a,
+    index: a,
+    value: null,
+    rendered: null,
+    level: 0,
+    hasChildNodes: !0,
+    childNodes: f,
+    textValue: ""
+  }));
+}
+class zo extends ko {
+  *[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 = ue(this.body.childNodes)) === null || e === void 0 ? void 0 : e.key) !== null && l !== void 0 ? l : null;
+  }
+  getLastKey() {
+    var e, l;
+    return (l = (e = de(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 i of l.childNodes) {
+        let r = this.columns[i.index];
+        if (n.has(r.key) && i.textValue && o.push(i.textValue), o.length === n.size) break;
+      }
+      return o.join(" ");
+    }
+    return "";
+  }
+  constructor(e, l, n) {
+    let o = /* @__PURE__ */ new Set(), i = null, r = [];
+    if (n?.showSelectionCheckboxes) {
+      let a = {
+        type: "column",
+        key: Fl,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: n?.showDragButtons ? 1 : 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isSelectionCell: !0
+        }
+      };
+      r.unshift(a);
+    }
+    if (n?.showDragButtons) {
+      let a = {
+        type: "column",
+        key: tt,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isDragButtonCell: !0
+        }
+      };
+      r.unshift(a);
+    }
+    let d = [], s = /* @__PURE__ */ new Map(), u = (a) => {
+      switch (a.type) {
+        case "body":
+          i = a;
+          break;
+        case "column":
+          s.set(a.key, a), a.hasChildNodes || (r.push(a), a.props.isRowHeader && o.add(a.key));
+          break;
+        case "item":
+          d.push(a);
+          return;
+      }
+      for (let p of a.childNodes) u(p);
+    };
+    for (let a of e) u(a);
+    let f = Il(s, r);
+    if (f.forEach((a, p) => d.splice(p, 0, a)), super({
+      columnCount: r.length,
+      items: d,
+      visitNode: (a) => (a.column = r[a.index], a)
+    }), this._size = 0, this.columns = r, this.rowHeaderColumnKeys = o, this.body = i, this.headerRows = f, this._size = [
+      ...i.childNodes
+    ].length, this.rowHeaderColumnKeys.size === 0) {
+      let a = this.columns.find((p) => {
+        var c, m;
+        return !(!((c = p.props) === null || c === void 0) && c.isDragButtonCell) && !(!((m = p.props) === null || m === void 0) && m.isSelectionCell);
+      });
+      a && this.rowHeaderColumnKeys.add(a.key);
+    }
+  }
+}
+const Ao = {
+  ascending: "descending",
+  descending: "ascending"
+};
+function Ro(t) {
+  let [e, l] = G(!1), { selectionMode: n = "none", showSelectionCheckboxes: o, showDragButtons: i } = t, r = K(() => ({
+    showSelectionCheckboxes: o && n !== "none",
+    showDragButtons: i,
+    selectionMode: n,
+    columns: []
+  }), [
+    t.children,
+    o,
+    n,
+    i
+  ]), d = Cn(t, M((a) => new zo(a, null, r), [
+    r
+  ]), r), { disabledKeys: s, selectionManager: u } = Eo({
+    ...t,
+    collection: d,
+    disabledBehavior: t.disabledBehavior || "selection"
+  });
+  var f;
+  return {
+    collection: d,
+    disabledKeys: s,
+    selectionManager: u,
+    showSelectionCheckboxes: t.showSelectionCheckboxes || !1,
+    sortDescriptor: (f = t.sortDescriptor) !== null && f !== void 0 ? f : null,
+    isKeyboardNavigationDisabled: d.size === 0 || e,
+    setKeyboardNavigationDisabled: l,
+    sort(a, p) {
+      var c, m;
+      (m = t.onSortChange) === null || m === void 0 || m.call(t, {
+        column: a,
+        direction: p ?? (((c = t.sortDescriptor) === null || c === void 0 ? void 0 : c.column) === a ? Ao[t.sortDescriptor.direction] : "ascending")
+      });
+    }
+  };
+}
+function To(t, e) {
+  let l = K(() => e ? t.collection.filter(e) : t.collection, [
+    t.collection,
+    e
+  ]), n = t.selectionManager.withCollection(l);
+  return {
+    ...t,
+    collection: l,
+    selectionManager: n
+  };
+}
+function Po(t) {
+  return t && t.__esModule ? t.default : t;
+}
+class Bo extends Pn {
+  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 r of this.getChildren(this.body.key)) {
+      let d = r.lastChildKey;
+      if (d != null) {
+        let s = this.getItem(d);
+        var o, i;
+        let u = ((o = s.colIndex) !== null && o !== void 0 ? o : s.index) + ((i = s.colSpan) !== null && i !== void 0 ? i : 1);
+        if (u !== this.columns.length && !n) throw new Error(`Cell count must match column count. Found ${u} cells and ${this.columns.length} columns.`);
+      }
+      this.rows.push(r);
+    }
+    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 i of this.getChildren(o.key)) n(i);
+    };
+    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 i = super.getKeyBefore(e);
+    return i != null && ((l = this.getItem(i)) === null || l === void 0 ? void 0 : l.type) === "tablebody" ? null : i;
+  }
+  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 i of this.getChildren(e)) {
+      let r = this.columns[i.index];
+      if (n.has(r.key) && i.textValue && o.push(i.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 ct(-1), this.body = new ft(-2), this.columnsDirty = !0;
+  }
+}
+const ut = /* @__PURE__ */ fe(null), Ko = /* @__PURE__ */ Y(function(e, l) {
+  let n = Q(l), o = P(null), i = P(null), [r, d] = G(0);
+  Qe(() => {
+    let u = o.current;
+    for (; u && u !== n.current && !Mn(u); ) u = u.parentElement;
+    i.current = u;
+  }, [
+    n
+  ]), Kn({
+    ref: i,
+    box: "border-box",
+    onResize() {
+      var u, f;
+      d((f = (u = i.current) === null || u === void 0 ? void 0 : u.clientWidth) !== null && f !== void 0 ? f : 0);
+    }
+  }), Qe(() => {
+    var u, f;
+    d((f = (u = i.current) === null || u === void 0 ? void 0 : u.clientWidth) !== null && f !== void 0 ? f : 0);
+  }, []);
+  let s = K(() => ({
+    tableRef: o,
+    scrollRef: i,
+    tableWidth: r,
+    useTableColumnResizeState: So,
+    onResizeStart: e.onResizeStart,
+    onResize: e.onResize,
+    onResizeEnd: e.onResizeEnd
+  }), [
+    o,
+    r,
+    e.onResizeStart,
+    e.onResize,
+    e.onResizeEnd
+  ]);
+  return /* @__PURE__ */ D.createElement("div", {
+    ...te(e, {
+      global: !0
+    }),
+    ref: n,
+    className: e.className || "react-aria-ResizableTableContainer",
+    style: e.style,
+    onScroll: e.onScroll
+  }, /* @__PURE__ */ D.createElement(ut.Provider, {
+    value: s
+  }, e.children));
+}), Mo = /* @__PURE__ */ fe(null), re = /* @__PURE__ */ fe(null), dt = /* @__PURE__ */ fe(null), No = /* @__PURE__ */ Y(function(e, l) {
+  var n;
+  [e, l] = Wt(e, l, Mo);
+  let o = Ot(e), { selectionBehavior: i, selectionMode: r, disallowEmptySelection: d } = o, s = !!(!((n = e.dragAndDropHooks) === null || n === void 0) && n.useDraggableCollectionState), u = K(() => ({
+    selectionBehavior: r === "none" ? null : i,
+    selectionMode: r,
+    disallowEmptySelection: d,
+    allowsDragging: s
+  }), [
+    i,
+    r,
+    d,
+    s
+  ]), f = /* @__PURE__ */ D.createElement(Vl.Provider, {
+    value: u
+  }, /* @__PURE__ */ D.createElement(Pe, e));
+  return /* @__PURE__ */ D.createElement(Rn, {
+    content: f,
+    createCollection: () => new Bo()
+  }, (a) => /* @__PURE__ */ D.createElement(Io, {
+    props: e,
+    forwardedRef: l,
+    selectionState: o,
+    collection: a
+  }));
+});
+let Fo = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("table", {
+    ...e,
+    ref: l
+  });
+});
+function Io({ props: t, forwardedRef: e, selectionState: l, collection: n }) {
+  [t, e] = Wt(t, e, kt);
+  let { shouldUseVirtualFocus: o, disallowTypeAhead: i, filter: r, ...d } = t, s = z(ut);
+  e = Q(K(() => yn(e, s?.tableRef), [
+    e,
+    s?.tableRef
+  ]));
+  let u = Ro({
+    ...d,
+    collection: n,
+    children: void 0,
+    UNSAFE_selectionState: l
+  }), f = To(u, r), { isVirtualized: a, layoutDelegate: p, dropTargetDelegate: c, CollectionRoot: m } = z(I), { dragAndDropHooks: h } = t, { gridProps: g } = so({
+    ...d,
+    layoutDelegate: p,
+    isVirtualized: a
+  }, f, e), b = f.selectionManager, y = !!h?.useDraggableCollectionState, v = !!h?.useDroppableCollectionState, C = P(y), $ = P(v);
+  ce(() => {
+    process.env.NODE_ENV !== "production" && (C.current !== y && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), $.current !== v && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."));
+  }, [
+    y,
+    v
+  ]);
+  let S, E, B, R = !1, k = null, N = P(null);
+  if (y && h) {
+    S = h.useDraggableCollectionState({
+      collection: f.collection,
+      selectionManager: b,
+      preview: h.renderDragPreview ? N : void 0
+    }), h.useDraggableCollection({}, S, e);
+    let _ = h.DragPreview;
+    k = h.renderDragPreview ? /* @__PURE__ */ D.createElement(_, {
+      ref: N
+    }, h.renderDragPreview) : null;
+  }
+  if (v && h) {
+    E = h.useDroppableCollectionState({
+      collection: f.collection,
+      selectionManager: b
+    });
+    let _ = new Yn({
+      collection: f.collection,
+      disabledKeys: b.disabledKeys,
+      disabledBehavior: b.disabledBehavior,
+      ref: e,
+      layoutDelegate: p
+    }), se = h.dropTargetDelegate || c || new h.ListDropTargetDelegate(n.rows, e);
+    B = h.useDroppableCollection({
+      keyboardDelegate: _,
+      dropTargetDelegate: se
+    }, E, e), R = E.isDropTarget({
+      type: "root"
+    });
+  }
+  let { focusProps: H, isFocused: O, isFocusVisible: W } = De(), F = me({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-Table",
+    values: {
+      isDropTarget: R,
+      isFocused: O,
+      isFocusVisible: W,
+      state: f
+    }
+  }), X = !!(y && !S?.isDisabled), U = F.style, le = null;
+  s && (le = s.useTableColumnResizeState({
+    tableWidth: s.tableWidth
+  }, f), a || (U = {
+    ...U,
+    tableLayout: "fixed",
+    width: "fit-content"
+  }));
+  let he = te(t, {
+    global: !0
+  });
+  var ne;
+  return /* @__PURE__ */ D.createElement(Ue, {
+    values: [
+      [
+        re,
+        f
+      ],
+      [
+        dt,
+        le
+      ],
+      [
+        Se,
+        {
+          dragAndDropHooks: h,
+          dragState: S,
+          dropState: E
+        }
+      ],
+      [
+        Dn,
+        {
+          render: qo
+        }
+      ],
+      [
+        kt,
+        null
+      ],
+      [
+        vn,
+        null
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(Vn, null, /* @__PURE__ */ D.createElement(Fo, {
+    ...j(he, F, g, H, B?.collectionProps),
+    style: U,
+    ref: e,
+    slot: t.slot || void 0,
+    onScroll: t.onScroll,
+    "data-allows-dragging": X || void 0,
+    "data-drop-target": R || void 0,
+    "data-focused": O || void 0,
+    "data-focus-visible": W || void 0
+  }, /* @__PURE__ */ D.createElement(zn, null, /* @__PURE__ */ D.createElement(m, {
+    collection: f.collection,
+    scrollRef: (ne = s?.scrollRef) !== null && ne !== void 0 ? ne : e,
+    persistedKeys: Sn(b, h, E)
+  })))), k);
+}
+const Vl = /* @__PURE__ */ fe(null);
+function Hl() {
+  return z(Vl);
+}
+class ct extends Ge {
+}
+ct.type = "tableheader";
+let Vo = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("thead", {
+    ...e,
+    ref: l
+  });
+});
+const Ho = /* @__PURE__ */ nt(ct, (t, e) => {
+  let l = z(re).collection, n = An({
+    items: l.headerRows,
+    children: M((s) => {
+      switch (s.type) {
+        case "headerrow":
+          return /* @__PURE__ */ D.createElement(Lo, {
+            item: s
+          });
+        default:
+          throw new Error("Unsupported node type in TableHeader: " + s.type);
+      }
+    }, [])
+  }), { rowGroupProps: o } = Kl(), { hoverProps: i, isHovered: r } = Be({
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), d = me({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-TableHeader",
+    values: {
+      isHovered: r
+    }
+  });
+  return /* @__PURE__ */ D.createElement(Vo, {
+    ...j(te(t, {
+      global: !0
+    }), o, i),
+    ...d,
+    ref: e,
+    "data-hovered": r || void 0
+  }, n);
+}, (t) => /* @__PURE__ */ D.createElement(Pe, {
+  dependencies: t.dependencies,
+  items: t.columns
+}, t.children));
+let Wo = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("tr", {
+    ...e,
+    ref: l
+  });
+});
+function Lo({ item: t }) {
+  let e = P(null), l = z(re), { isVirtualized: n, CollectionBranch: o } = z(I), { rowProps: i } = mo({
+    node: t,
+    isVirtualized: n
+  }, l, e), { checkboxProps: r } = go(l);
+  return /* @__PURE__ */ D.createElement(Wo, {
+    ...i,
+    ref: e
+  }, /* @__PURE__ */ D.createElement(Ue, {
+    values: [
+      [
+        Ht,
+        {
+          slots: {
+            selection: r
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(o, {
+    collection: l.collection,
+    parent: t
+  })));
+}
+class Wl extends Ge {
+}
+Wl.type = "column";
+let Oo = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("th", {
+    ...e,
+    ref: l
+  });
+});
+const jo = /* @__PURE__ */ Ut(Wl, (t, e, l) => {
+  var n, o;
+  let i = Q(e), r = z(re), { isVirtualized: d } = z(I), { columnHeaderProps: s, isPressed: u } = co({
+    node: l,
+    isVirtualized: d
+  }, r, i), { isFocused: f, isFocusVisible: a, focusProps: p } = De(), c = z(dt), m = !1;
+  if (c) m = c.resizingColumn === l.key;
+  else if (process.env.NODE_ENV !== "production")
+    for (let C in [
+      "width",
+      "defaultWidth",
+      "minWidth",
+      "maxWidth"
+    ]) C in l.props && console.warn(`The ${C} 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 } = Be({
+    isDisabled: !t.allowsSorting
+  }), b = me({
+    ...t,
+    id: void 0,
+    children: l.rendered,
+    defaultClassName: "react-aria-Column",
+    values: {
+      isHovered: g,
+      isPressed: u,
+      isFocused: f,
+      isFocusVisible: a,
+      allowsSorting: l.props.allowsSorting,
+      sortDirection: ((n = r.sortDescriptor) === null || n === void 0 ? void 0 : n.column) === l.key ? r.sortDescriptor.direction : void 0,
+      isResizing: m,
+      startResize: () => {
+        if (c)
+          c.startResize(l.key), r.setKeyboardNavigationDisabled(!0);
+        else throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+      },
+      sort: (C) => {
+        r.sort(l.key, C);
+      }
+    }
+  }), y = b.style;
+  c && (y = {
+    ...y,
+    width: c.getColumnWidth(l.key)
+  });
+  let v = te(t, {
+    global: !0
+  });
+  return delete v.id, /* @__PURE__ */ D.createElement(Oo, {
+    ...j(v, s, p, h),
+    ...b,
+    style: y,
+    ref: i,
+    "data-hovered": g || void 0,
+    "data-pressed": u || void 0,
+    "data-focused": f || void 0,
+    "data-focus-visible": a || void 0,
+    "data-resizing": m || void 0,
+    "data-allows-sorting": l.props.allowsSorting || void 0,
+    "data-sort-direction": ((o = r.sortDescriptor) === null || o === void 0 ? void 0 : o.column) === l.key ? r.sortDescriptor.direction : void 0
+  }, /* @__PURE__ */ D.createElement(Ue, {
+    values: [
+      [
+        Ll,
+        {
+          column: l,
+          triggerRef: i
+        }
+      ],
+      [
+        I,
+        jt
+      ]
+    ]
+  }, b.children));
+}), Ll = /* @__PURE__ */ fe(null), Uo = /* @__PURE__ */ Y(function(e, l) {
+  let n = z(dt);
+  if (!n) throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+  let o = Ke(Po(En), "react-aria-components"), { onResizeStart: i, onResize: r, onResizeEnd: d } = z(ut), { column: s, triggerRef: u } = z(Ll), f = P(null), { resizerProps: a, inputProps: p, isResizing: c } = yo({
+    column: s,
+    "aria-label": e["aria-label"] || o.format("tableResizer"),
+    onResizeStart: i,
+    onResize: r,
+    onResizeEnd: d,
+    triggerRef: u
+  }, n, f), { focusProps: m, isFocused: h, isFocusVisible: g } = De(), { hoverProps: b, isHovered: y } = Be(e), v = n.getColumnMinWidth(s.key) >= n.getColumnWidth(s.key), C = n.getColumnMaxWidth(s.key) <= n.getColumnWidth(s.key), { direction: $ } = Ee(), S = "both";
+  v ? S = $ === "rtl" ? "right" : "left" : C ? S = $ === "rtl" ? "left" : "right" : S = "both";
+  let E = Q(l), [B, R] = G("");
+  ce(() => {
+    if (!E.current) return;
+    let F = window.getComputedStyle(E.current);
+    R(F.cursor);
+  }, [
+    E,
+    S
+  ]);
+  let k = me({
+    ...e,
+    defaultClassName: "react-aria-ColumnResizer",
+    values: {
+      isFocused: h,
+      isFocusVisible: g,
+      isResizing: c,
+      isHovered: y,
+      resizableDirection: S
+    }
+  }), [N, H] = G(!1), O = (F) => {
+    F.pointerType === "mouse" && H(!0);
+  };
+  !c && N && H(!1);
+  let W = te(e, {
+    global: !0
+  });
+  return /* @__PURE__ */ D.createElement("div", {
+    ref: E,
+    role: "presentation",
+    ...j(W, k, a, {
+      onPointerDown: O
+    }, b),
+    "data-hovered": y || void 0,
+    "data-focused": h || void 0,
+    "data-focus-visible": g || void 0,
+    "data-resizing": c || void 0,
+    "data-resizable-direction": S
+  }, k.children, /* @__PURE__ */ D.createElement("input", {
+    ref: f,
+    ...j(p, m)
+  }), c && N && /* @__PURE__ */ Nn.createPortal(/* @__PURE__ */ D.createElement("div", {
+    style: {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      bottom: 0,
+      right: 0,
+      cursor: B
+    }
+  }), document.body));
+});
+class ft extends Tn {
+}
+ft.type = "tablebody";
+let Go = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("tbody", {
+    ...e,
+    ref: l
+  });
+});
+const Yo = /* @__PURE__ */ nt(ft, (t, e) => {
+  let l = z(re), { isVirtualized: n } = z(I), o = l.collection, { CollectionBranch: i } = z(I), { dragAndDropHooks: r, dropState: d } = z(Se), s = !!r?.useDroppableCollectionState && !d?.isDisabled;
+  var u;
+  let f = s && !!d && ((u = d.isDropTarget({
+    type: "root"
+  })) !== null && u !== void 0 ? u : !1), a = o.size === 0, p = {
+    isDropTarget: f,
+    isEmpty: a
+  }, c = me({
+    ...t,
+    id: void 0,
+    children: void 0,
+    defaultClassName: "react-aria-TableBody",
+    values: p
+  }), m, h = o.columnCount;
+  if (a && t.renderEmptyState && l) {
+    let y = {}, v = {}, C = {};
+    n ? (v["aria-colspan"] = h, C = {
+      display: "contents"
+    }) : v.colSpan = h, m = /* @__PURE__ */ D.createElement(je, {
+      role: "row",
+      ...y,
+      style: C
+    }, /* @__PURE__ */ D.createElement(Xe, {
+      role: "rowheader",
+      ...v,
+      style: C
+    }, t.renderEmptyState(p)));
+  }
+  let { rowGroupProps: g } = Kl(), b = te(t, {
+    global: !0
+  });
+  return /* @__PURE__ */ D.createElement(Go, {
+    ...j(b, c, g),
+    ref: e,
+    "data-empty": a || void 0
+  }, s && /* @__PURE__ */ D.createElement(ei, null), /* @__PURE__ */ D.createElement(i, {
+    collection: o,
+    parent: o.body,
+    renderDropIndicator: wn(r, d)
+  }), m);
+});
+class Ol extends Ge {
+  filter(e, l, n) {
+    let o = e.getChildren(this.key);
+    for (let i of o) if (n(i.textValue, i)) {
+      let r = this.clone();
+      return l.addDescendants(r, e), r;
+    }
+    return null;
+  }
+}
+Ol.type = "item";
+let je = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("tr", {
+    ...e,
+    ref: l
+  });
+});
+const Bt = /* @__PURE__ */ nt(Ol, (t, e, l) => {
+  let n = Q(e), o = z(re), { dragAndDropHooks: i, dragState: r, dropState: d } = z(Se), { isVirtualized: s, CollectionBranch: u } = z(I), { rowProps: f, ...a } = fo({
+    node: l,
+    shouldSelectOnPressUp: !!r,
+    isVirtualized: s
+  }, o, n), { isFocused: p, isFocusVisible: c, focusProps: m } = De(), { isFocusVisible: h, focusProps: g } = De({
+    within: !0
+  }), { hoverProps: b, isHovered: y } = Be({
+    isDisabled: !a.allowsSelection && !a.hasAction,
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), { checkboxProps: v } = bo({
+    key: l.key
+  }, o), C;
+  r && i && (C = i.useDraggableItem({
+    key: l.key,
+    hasDragButton: !0
+  }, r));
+  let $, S = P(null), { visuallyHiddenProps: E } = Ye();
+  d && i && ($ = i.useDropIndicator({
+    target: {
+      type: "item",
+      key: l.key,
+      dropPosition: "on"
+    }
+  }, d, S));
+  let B = P(null);
+  ce(() => {
+    r && !B.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 R = r && r.isDragging(l.key), { children: k, ...N } = t, H = me({
+    ...N,
+    id: void 0,
+    defaultClassName: "react-aria-Row",
+    values: {
+      ...a,
+      isHovered: y,
+      isFocused: p,
+      isFocusVisible: c,
+      selectionMode: o.selectionManager.selectionMode,
+      selectionBehavior: o.selectionManager.selectionBehavior,
+      isDragging: R,
+      isDropTarget: $?.isDropTarget,
+      isFocusVisibleWithin: h,
+      id: l.key
+    }
+  }), O = te(t, {
+    global: !0
+  });
+  return delete O.id, delete O.onClick, /* @__PURE__ */ D.createElement(D.Fragment, null, $ && !$.isHidden && /* @__PURE__ */ D.createElement(je, {
+    role: "row",
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ D.createElement(Xe, {
+    role: "gridcell",
+    colSpan: o.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    role: "button",
+    ...E,
+    ...$.dropIndicatorProps,
+    ref: S
+  }))), /* @__PURE__ */ D.createElement(je, {
+    ...j(O, H, f, m, b, C?.dragProps, g),
+    ref: n,
+    "data-disabled": a.isDisabled || void 0,
+    "data-selected": a.isSelected || void 0,
+    "data-hovered": y || void 0,
+    "data-focused": a.isFocused || void 0,
+    "data-focus-visible": c || void 0,
+    "data-pressed": a.isPressed || void 0,
+    "data-dragging": R || void 0,
+    "data-drop-target": $?.isDropTarget || void 0,
+    "data-selection-mode": o.selectionManager.selectionMode === "none" ? void 0 : o.selectionManager.selectionMode,
+    "data-focus-visible-within": h || void 0
+  }, /* @__PURE__ */ D.createElement(Ue, {
+    values: [
+      [
+        Ht,
+        {
+          slots: {
+            [zt]: {},
+            selection: v
+          }
+        }
+      ],
+      [
+        Vt,
+        {
+          slots: {
+            [zt]: {},
+            drag: {
+              ...C?.dragButtonProps,
+              ref: B,
+              style: {
+                pointerEvents: "none"
+              }
+            }
+          }
+        }
+      ],
+      [
+        kn,
+        {
+          isSelected: a.isSelected
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(u, {
+    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__ */ D.createElement(Pe, {
+    dependencies: e,
+    items: t.columns,
+    idScope: t.id
+  }, t.children);
+});
+class jl extends Ge {
+}
+jl.type = "cell";
+let Xe = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("td", {
+    ...e,
+    ref: l
+  });
+});
+const Xo = /* @__PURE__ */ Ut(jl, (t, e, l) => {
+  let n = Q(e), o = z(re), { dragState: i } = z(Se), { isVirtualized: r } = z(I);
+  l.column = o.collection.columns[l.index];
+  let { gridCellProps: d, isPressed: s } = po({
+    node: l,
+    shouldSelectOnPressUp: !!i,
+    isVirtualized: r
+  }, o, n), { isFocused: u, isFocusVisible: f, focusProps: a } = De(), { hoverProps: p, isHovered: c } = Be({}), m = l.parentKey != null ? o.selectionManager.isSelected(l.parentKey) : !1, h = me({
+    ...t,
+    id: void 0,
+    defaultClassName: "react-aria-Cell",
+    values: {
+      isFocused: u,
+      isFocusVisible: f,
+      isPressed: s,
+      isHovered: c,
+      isSelected: m,
+      id: l.key
+    }
+  }), g = te(t, {
+    global: !0
+  });
+  return delete g.id, /* @__PURE__ */ D.createElement(Xe, {
+    ...j(g, h, d, a, p),
+    ref: n,
+    "data-focused": u || void 0,
+    "data-focus-visible": f || void 0,
+    "data-pressed": s || void 0,
+    "data-selected": m || void 0
+  }, /* @__PURE__ */ D.createElement(I.Provider, {
+    value: jt
+  }, h.children));
+});
+function qo(t, e) {
+  e = Q(e);
+  let { dragAndDropHooks: l, dropState: n } = z(Se), o = P(null), { dropIndicatorProps: i, isHidden: r, isDropTarget: d } = l.useDropIndicator(t, n, o);
+  return r ? null : /* @__PURE__ */ D.createElement(_o, {
+    ...t,
+    dropIndicatorProps: i,
+    isDropTarget: d,
+    buttonRef: o,
+    ref: e
+  });
+}
+let Zo = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("tr", {
+    ...e,
+    ref: l
+  });
+}), Jo = /* @__PURE__ */ Y(function(e, l) {
+  let { isVirtualized: n } = z(I);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("td", {
+    ...e,
+    ref: l
+  });
+});
+function Qo(t, e) {
+  let { dropIndicatorProps: l, isDropTarget: n, buttonRef: o, ...i } = t, r = z(re), { visuallyHiddenProps: d } = Ye(), s = me({
+    ...i,
+    defaultClassName: "react-aria-DropIndicator",
+    values: {
+      isDropTarget: n
+    }
+  });
+  return /* @__PURE__ */ D.createElement(Zo, {
+    ...te(t, {
+      global: !0
+    }),
+    ...s,
+    role: "row",
+    ref: e,
+    "data-drop-target": n || void 0
+  }, /* @__PURE__ */ D.createElement(Jo, {
+    role: "gridcell",
+    colSpan: r.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    ...d,
+    role: "button",
+    ...l,
+    ref: o
+  }), s.children));
+}
+const _o = /* @__PURE__ */ Y(Qo);
+function ei() {
+  let t = z(re), { dragAndDropHooks: e, dropState: l } = z(Se), n = P(null), { dropIndicatorProps: o } = e.useDropIndicator({
+    target: {
+      type: "root"
+    }
+  }, l, n), i = l.isDropTarget({
+    type: "root"
+  }), { visuallyHiddenProps: r } = Ye();
+  return !i && o["aria-hidden"] ? null : /* @__PURE__ */ D.createElement(je, {
+    role: "row",
+    "aria-hidden": o["aria-hidden"],
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ D.createElement(Xe, {
+    role: "gridcell",
+    colSpan: t.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    role: "button",
+    ...r,
+    ...o,
+    ref: n
+  })));
+}
+const { withProvider: ti, withContext: Z } = /* @__PURE__ */ Ql({
+  key: "dataTable"
+}), li = /* @__PURE__ */ ti("div", "root"), ni = /* @__PURE__ */ Z("table", "table"), oi = /* @__PURE__ */ Z("tr", "header"), ii = /* @__PURE__ */ Z("th", "column"), ri = /* @__PURE__ */ Z("tbody", "body"), Kt = /* @__PURE__ */ Z("tr", "row"), ai = /* @__PURE__ */ Z("td", "cell"), si = /* @__PURE__ */ Z("footer", "footer"), ui = /* @__PURE__ */ Z("td", "selectionCell"), Ul = /* @__PURE__ */ Z("button", "expandButton"), di = /* @__PURE__ */ Z("span", "nestedIcon"), ci = /* @__PURE__ */ Z("span", "headerSortIcon"), fi = /* @__PURE__ */ Z("div", "columnResizer"), qe = /* @__PURE__ */ fe(null);
+qe.displayName = "DataTable.Context";
+const mt = /* @__PURE__ */ fe(null);
+mt.displayName = "CustomSettings.Context";
+const pe = () => {
+  const t = z(
+    qe
+  );
+  if (!t)
+    throw new Error("DataTable components must be used within DataTable.Root");
+  return t;
+}, mi = () => {
+  const t = z(mt);
+  if (!t)
+    throw new Error(
+      "CustomSettings components must be used within CustomSettings.Root"
+    );
+  return t;
+};
+function Gl(t, e, l, n) {
+  if (!e) return t;
+  const o = e.toLowerCase();
+  return t.map((i) => {
+    const r = l.some((d) => {
+      const s = d.accessor(i);
+      return typeof s == "string" && s.toLowerCase().includes(o);
+    });
+    if (n && i[n]) {
+      let d = i[n];
+      if (Array.isArray(i[n])) {
+        if (d = Gl(
+          i[n],
+          e,
+          l,
+          n
+        ), r || d && Array.isArray(d) && d.length > 0)
+          return { ...i, [n]: d };
+      } else if (r)
+        return { ...i, [n]: d };
+      return null;
+    } else
+      return r ? i : null;
+  }).filter(Boolean);
+}
+function Yl(t, e, l, n, o) {
+  const i = [], r = [];
+  t.forEach((u) => {
+    o?.has(u.id) ? i.push(u) : r.push(u);
+  });
+  let d = r;
+  if (e) {
+    const u = l.find((f) => f.id === e.column);
+    u && (d = [...r].sort((f, a) => {
+      const p = u.accessor(f), c = u.accessor(a);
+      if (p == null && c == null) return 0;
+      if (p == null) return 1;
+      if (c == null) return -1;
+      let m = p, h = c;
+      return typeof p == "number" && typeof c == "number" ? (m = p, h = c) : (m = String(p).toLowerCase(), h = String(c).toLowerCase()), m < h ? e.direction === "ascending" ? -1 : 1 : m > h ? e.direction === "ascending" ? 1 : -1 : 0;
+    }));
+  }
+  return [...i, ...d].map((u) => !n || !u[n] ? u : {
+    ...u,
+    [n]: Array.isArray(u[n]) ? Yl(
+      u[n],
+      e,
+      l,
+      n,
+      o
+    ) : u[n]
+  });
+}
+function Xl(t, e) {
+  return e ? t.some(
+    (l) => l[e] && (Array.isArray(l[e]) ? l[e].length > 0 : !0) || Array.isArray(l[e]) && Xl(l[e], e)
+  ) : !1;
+}
+const pt = function(e) {
+  const {
+    ref: l,
+    columns: n = [],
+    rows: o = [],
+    visibleColumns: i,
+    search: r,
+    sortDescriptor: d,
+    defaultSortDescriptor: s,
+    onSortChange: u,
+    selectedKeys: f,
+    defaultSelectedKeys: a,
+    onSelectionChange: p,
+    selectionMode: c = "none",
+    disallowEmptySelection: m = !1,
+    allowsSorting: h = !1,
+    maxHeight: g,
+    isTruncated: b = !1,
+    density: y = "default",
+    nestedKey: v,
+    onRowClick: C,
+    onDetailsClick: $,
+    disabledKeys: S,
+    onRowAction: E,
+    isResizable: B,
+    pinnedRows: R,
+    defaultPinnedRows: k,
+    onPinToggle: N,
+    onColumnsChange: H,
+    onSettingsChange: O,
+    customSettings: W,
+    children: F,
+    ...X
+  } = e, U = P(null), le = Q(Te(U, l)), [he, ne] = G(s), [_, se] = G({}), [w, T] = G(
+    () => k || /* @__PURE__ */ new Set()
+  ), V = d ?? he, ge = R ?? w, ve = K(() => {
+    if (!i)
+      return n;
+    const q = new Map(n.map((J) => [J.id, J]));
+    return i.map((J) => q.get(J)).filter((J) => J !== void 0);
+  }, [n, i]), Ne = K(
+    () => r ? Gl(o, r, ve, v) : o,
+    [o, r, ve, v]
+  ), Ze = K(
+    () => Yl(
+      Ne,
+      V,
+      ve,
+      v,
+      ge
+    ),
+    [Ne, V, ve, v, ge]
+  ), $t = Xl(Ze, v), xt = c !== "none", Ct = M(
+    (q) => se((J) => ({ ...J, [q]: !J[q] })),
+    []
+  ), wt = M(
+    (q) => {
+      N ? N(q) : T((J) => {
+        const Fe = new Set(J);
+        return Fe.has(q) ? Fe.delete(q) : Fe.add(q), Fe;
+      });
+    },
+    [N]
+  ), Dt = M(
+    (q) => {
+      u ? u(q) : ne(q);
+    },
+    [u]
+  ), Zl = K(
+    () => ({
+      columns: n,
+      rows: o,
+      visibleColumns: i,
+      search: r,
+      sortDescriptor: V,
+      selectedKeys: f,
+      defaultSelectedKeys: a,
+      expanded: _,
+      allowsSorting: h,
+      selectionMode: c,
+      disallowEmptySelection: m,
+      maxHeight: g,
+      isTruncated: b,
+      density: y,
+      nestedKey: v,
+      onSortChange: Dt,
+      onSelectionChange: p,
+      onRowClick: C,
+      onDetailsClick: $,
+      toggleExpand: Ct,
+      activeColumns: ve,
+      filteredRows: Ne,
+      sortedRows: Ze,
+      showExpandColumn: $t,
+      showSelectionColumn: xt,
+      isResizable: B,
+      disabledKeys: S,
+      onRowAction: E,
+      pinnedRows: ge,
+      onPinToggle: N,
+      togglePin: wt,
+      onColumnsChange: H,
+      onSettingsChange: O
+    }),
+    [
+      n,
+      o,
+      i,
+      r,
+      V,
+      f,
+      a,
+      _,
+      h,
+      c,
+      m,
+      g,
+      b,
+      y,
+      v,
+      Dt,
+      p,
+      C,
+      $,
+      Ct,
+      ve,
+      Ne,
+      Ze,
+      $t,
+      xt,
+      B,
+      S,
+      E,
+      ge,
+      N,
+      wt,
+      H,
+      O
+    ]
+  ), Jl = K(
+    () => ({
+      customSettings: W
+    }),
+    [W]
+  );
+  return /* @__PURE__ */ x(
+    li,
+    {
+      ref: le,
+      truncated: b,
+      density: y,
+      maxH: g,
+      ...X,
+      asChild: !0,
+      children: /* @__PURE__ */ x(Ko, { children: /* @__PURE__ */ x(
+        qe.Provider,
+        {
+          value: Zl,
+          children: /* @__PURE__ */ x(mt.Provider, { value: Jl, children: F })
+        }
+      ) })
+    }
+  );
+};
+pt.displayName = "DataTable.Root";
+const pi = {
+  comfortable: "Comfortable",
+  comfortableAriaLabel: "Comfortable section",
+  compact: "Compact",
+  compactAriaLabel: "Compact section",
+  dataTable: "Data table",
+  dataTableBody: "Data table body",
+  dataTableHeader: "Data table header",
+  expandRows: "Expand rows",
+  fullText: "Full text",
+  fullTextAriaLabel: "Full text section",
+  hiddenColumns: "Hidden columns",
+  hiddenColumnsAriaLabel: "Hidden columns list",
+  hideColumn: "Hide column",
+  layoutSettings: "Layout settings",
+  layoutSettingsAriaLabel: "Layout settings section",
+  noHiddenColumns: "No Hidden columns",
+  pinRows: "Pin rows",
+  reset: "Reset columns",
+  resizeColumn: "Resize column",
+  rowDensity: "Row density",
+  rowDensityAriaLabel: "Row density section",
+  searchHiddenColumns: "Search...",
+  selectRow: "Select row",
+  settings: "Table settings",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Text previews",
+  textPreviewsAriaLabel: "Text previews section",
+  textVisibility: "Text visibility",
+  textVisibilityAriaLabel: "Text visibility section",
+  visibleColumns: "Visible columns",
+  visibleColumnsAria: "Visible columns list",
+  visibleColumnsList: "Visible columns"
+}, hi = {
+  comfortable: "Komfortabel",
+  comfortableAriaLabel: "Komfortabler Bereich",
+  compact: "Kompakt",
+  compactAriaLabel: "Kompakter Bereich",
+  dataTable: "Datentabelle",
+  dataTableBody: "Datentabellenkörper",
+  dataTableHeader: "Datentabellenüberschrift",
+  expandRows: "Zeilen erweitern",
+  fullText: "Vollständiger Text",
+  fullTextAriaLabel: "Volltextbereich",
+  hiddenColumns: "Ausgeblendete Spalten",
+  hiddenColumnsAriaLabel: "Ausgeblendete Spaltenliste",
+  hideColumn: "Spalte ausblenden",
+  layoutSettings: "Layout-Einstellungen",
+  layoutSettingsAriaLabel: "Bereich Layout-Einstellungen",
+  noHiddenColumns: "Keine ausgeblendeten Spalten",
+  pinRows: "Zeilen fixieren",
+  reset: "Spalten zurücksetzen",
+  resizeColumn: "Spalte vergrößern",
+  rowDensity: "Zeilendichte",
+  rowDensityAriaLabel: "Abschnitt Zellendichte",
+  searchHiddenColumns: "Suche ...",
+  selectRow: "Zeile auswählen",
+  settings: "Tabellen-Einstellungen",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Textvorschau",
+  textPreviewsAriaLabel: "Abschnitt Textvorschau",
+  textVisibility: "Textsichtbarkeit",
+  textVisibilityAriaLabel: "Abschnitt Textsichtbarkeit",
+  visibleColumns: "Sichtbare Spalten",
+  visibleColumnsAria: "Sichtbare Spaltenliste",
+  visibleColumnsList: "Sichtbare Spalten"
+}, bi = {
+  comfortable: "Cómoda",
+  comfortableAriaLabel: "Sección cómoda",
+  compact: "Compacta",
+  compactAriaLabel: "Sección compacta",
+  dataTable: "Tabla de datos",
+  dataTableBody: "Cuerpo de la tabla de datos",
+  dataTableHeader: "Encabezamiento de la tabla de datos",
+  expandRows: "Extender filas",
+  fullText: "Texto completo",
+  fullTextAriaLabel: "Sección de texto completo",
+  hiddenColumns: "Columnas ocultas",
+  hiddenColumnsAriaLabel: "Lista de columnas ocultas",
+  hideColumn: "Ocultar columna",
+  layoutSettings: "Configuraciones de formato",
+  layoutSettingsAriaLabel: "Sección de configuraciones de formato",
+  noHiddenColumns: "Sin columnas ocultas",
+  pinRows: "Fijar filas",
+  reset: "Restablecer columnas",
+  resizeColumn: "Ajustar tamaño de columna",
+  rowDensity: "Densidad de filas",
+  rowDensityAriaLabel: "Sección de densidad de filas",
+  searchHiddenColumns: "Buscar...",
+  selectRow: "Seleccionar fila",
+  settings: "Configuraciones de tablas",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Vistas preliminares de texto",
+  textPreviewsAriaLabel: "Sección de vistas preliminares de texto",
+  textVisibility: "Visibilidad de texto",
+  textVisibilityAriaLabel: "Sección de visibilidad de texto",
+  visibleColumns: "Columnas visibles",
+  visibleColumnsAria: "Lista de columnas visibles",
+  visibleColumnsList: "Columnas visibles"
+}, gi = {
+  comfortable: "Confortable",
+  comfortableAriaLabel: "Section Confortable",
+  compact: "Compact",
+  compactAriaLabel: "Section Compact",
+  dataTable: "Tableau de données",
+  dataTableBody: "Corps du tableau de données",
+  dataTableHeader: "En-tête du tableau de données",
+  expandRows: "Agrandir les lignes",
+  fullText: "Texte complet",
+  fullTextAriaLabel: "Section Texte complet",
+  hiddenColumns: "Colonnes masquées",
+  hiddenColumnsAriaLabel: "Liste des colonnes masquées",
+  hideColumn: "Masquer la colonne",
+  layoutSettings: "Paramètres de disposition",
+  layoutSettingsAriaLabel: "Section Paramètres de disposition",
+  noHiddenColumns: "Pas de colonnes masquées",
+  pinRows: "Épingler les lignes",
+  reset: "Réinitialiser les colonnes",
+  resizeColumn: "Modifier la taille de la colonne",
+  rowDensity: "Densité des lignes",
+  rowDensityAriaLabel: "Section Densité des lignes",
+  searchHiddenColumns: "Rechercher...",
+  selectRow: "Sélectionner une ligne",
+  settings: "Paramètres du tableau",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Aperçu du texte",
+  textPreviewsAriaLabel: "Section Aperçu du texte",
+  textVisibility: "Visibilité du texte",
+  textVisibilityAriaLabel: "Section Visibilité du texte",
+  visibleColumns: "Colonnes visibles",
+  visibleColumnsAria: "Liste des colonnes visibles",
+  visibleColumnsList: "Colonnes visibles"
+}, vi = {
+  comfortable: "Confortável",
+  comfortableAriaLabel: "Seção confortável",
+  compact: "Compacto",
+  compactAriaLabel: "Seção compacta",
+  dataTable: "Tabela de dados",
+  dataTableBody: "Corpo da tabela de dados",
+  dataTableHeader: "Cabeçalho da tabela de dados",
+  expandRows: "Expandir linhas",
+  fullText: "Texto completo",
+  fullTextAriaLabel: "Seção de texto completo",
+  hiddenColumns: "Colunas ocultas",
+  hiddenColumnsAriaLabel: "Lista de colunas ocultas",
+  hideColumn: "Ocultar coluna",
+  layoutSettings: "Configurações de layout",
+  layoutSettingsAriaLabel: "Seção de configurações de layout",
+  noHiddenColumns: "Sem colunas ocultas",
+  pinRows: "Fixar linhas",
+  reset: "Redefinir colunas",
+  resizeColumn: "Redimensionar colunas",
+  rowDensity: "Densidade da linha",
+  rowDensityAriaLabel: "Seção de densidade da linha",
+  searchHiddenColumns: "Buscar...",
+  selectRow: "Selecionar linha",
+  settings: "Configurações da tabela",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Pré-visualizações de texto",
+  textPreviewsAriaLabel: "Seção de pré-visualizações de texto",
+  textVisibility: "Visibilidade do texto",
+  textVisibilityAriaLabel: "Seção de visibilidade do texto",
+  visibleColumns: "Colunas visíveis",
+  visibleColumnsAria: "Lista de colunas visíveis",
+  visibleColumnsList: "Colunas visíveis"
+}, ae = {
+  en: /* @__PURE__ */ ze(pi),
+  de: /* @__PURE__ */ ze(hi),
+  es: /* @__PURE__ */ ze(bi),
+  "fr-FR": /* @__PURE__ */ ze(gi),
+  "pt-BR": /* @__PURE__ */ ze(vi)
+}, ht = function({
+  ref: e,
+  children: l,
+  "aria-label": n,
+  ...o
+}) {
+  const i = P(null), r = Q(Te(i, e)), d = ie(ae), {
+    sortDescriptor: s,
+    onSortChange: u,
+    selectionMode: f,
+    onSelectionChange: a,
+    selectedKeys: p,
+    defaultSelectedKeys: c,
+    disallowEmptySelection: m,
+    disabledKeys: h
+  } = pe(), [g, b] = ke(o), y = n ?? d.format("dataTable"), v = s ? {
+    column: s.column,
+    direction: s.direction
+  } : void 0;
+  return /* @__PURE__ */ x(ni, { ...g, asChild: !0, children: /* @__PURE__ */ x(
+    No,
+    {
+      ref: r,
+      "aria-label": y,
+      sortDescriptor: v,
+      onSortChange: ($) => {
+        $ && u && u({
+          column: String($.column),
+          direction: $.direction
+        });
+      },
+      selectedKeys: p,
+      defaultSelectedKeys: c,
+      onSelectionChange: a,
+      selectionMode: f,
+      disallowEmptySelection: m,
+      disabledKeys: h,
+      disabledBehavior: "all",
+      ...b,
+      children: l
+    }
+  ) });
+};
+ht.displayName = "DataTable.Table";
+const we = ({
+  children: t,
+  ref: e,
+  column: l,
+  isInternalColumn: n,
+  width: o,
+  minWidth: i,
+  maxWidth: r,
+  ...d
+}) => {
+  const s = ie(ae), { sortDescriptor: u, isResizable: f } = pe(), a = u?.column === l?.id, p = l?.isResizable !== void 0 ? l?.isResizable : f, [c, m] = ke(d);
+  return /* @__PURE__ */ x(ii, { ...c, asChild: !0, children: /* @__PURE__ */ x(
+    jo,
+    {
+      width: o,
+      minWidth: i,
+      maxWidth: r,
+      ref: e,
+      ...m,
+      children: (h) => {
+        const { allowsSorting: g } = h;
+        return n ? typeof t == "function" ? t(h) : t : /* @__PURE__ */ A(
+          eo,
+          {
+            tabIndex: p || g ? -1 : 0,
+            className: "nimbus-data-table__column-container",
+            children: [
+              /* @__PURE__ */ x(
+                Ft,
+                {
+                  orientation: "vertical",
+                  className: "data-table-column-divider"
+                }
+              ),
+              typeof t == "function" ? t(h) : t,
+              g && /* @__PURE__ */ x(
+                ci,
+                {
+                  "aria-hidden": "true",
+                  "data-sort-active": a,
+                  "data-sort-direction": a ? u?.direction : "none",
+                  children: /* @__PURE__ */ x(_l, {})
+                }
+              ),
+              p && /* @__PURE__ */ x(Uo, { "aria-label": s.format("resizeColumn"), children: ({ isResizing: b, isFocused: y, isHovered: v }) => /* @__PURE__ */ x(
+                fi,
+                {
+                  "data-resizing": b,
+                  "data-focused": y,
+                  "data-hovered": v
+                }
+              ) })
+            ]
+          }
+        );
+      }
+    }
+  ) });
+};
+we.displayName = "DataTable.Column";
+const bt = ({
+  ref: t,
+  "aria-label": e,
+  ...l
+}) => {
+  const n = ie(ae), { activeColumns: o, allowsSorting: i, maxHeight: r, showExpandColumn: d } = pe(), { selectionBehavior: s, selectionMode: u } = Hl(), [f, a] = ke(l), p = e ?? n.format("dataTableHeader");
+  return /* @__PURE__ */ x(oi, { ...f, asChild: !0, children: /* @__PURE__ */ A(
+    Ho,
+    {
+      ref: t,
+      "aria-label": p,
+      className: "data-table-header",
+      ...r && { "data-sticky": !0 },
+      columns: o,
+      ...a,
+      children: [
+        s === "toggle" && /* @__PURE__ */ x(
+          we,
+          {
+            id: "selection",
+            className: "selection-column-header",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            children: u === "multiple" && /* @__PURE__ */ x(Xt, { slot: "selection" })
+          }
+        ),
+        d && /* @__PURE__ */ x(
+          we,
+          {
+            className: "expand-column-header",
+            maxWidth: s === "toggle" ? 24 : 72,
+            minWidth: s === "toggle" ? 24 : 72,
+            allowsSorting: !1,
+            "aria-label": n.format("expandRows"),
+            isInternalColumn: !0,
+            children: /* @__PURE__ */ x(Tt, { children: n.format("expandRows") })
+          }
+        ),
+        /* @__PURE__ */ x(Pe, { items: o, children: (c) => /* @__PURE__ */ A(
+          we,
+          {
+            allowsSorting: (
+              // use column.isSortable if defined, and fallback to allowsSorting if not
+              c.isSortable !== void 0 ? c.isSortable : i
+            ),
+            isRowHeader: !0,
+            width: c.width,
+            defaultWidth: c.defaultWidth,
+            minWidth: c.minWidth ?? 150,
+            maxWidth: c.maxWidth,
+            column: c,
+            children: [
+              /* @__PURE__ */ x("span", { "data-multiline-header": !0, children: c.header }),
+              c.headerIcon && /* @__PURE__ */ x(oe, { as: "span", ml: "200", children: c.headerIcon })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ x(
+          we,
+          {
+            className: "pin-rows-column-header",
+            id: "pin-rows",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            "aria-label": n.format("pinRows"),
+            children: /* @__PURE__ */ x(Tt, { children: n.format("pinRows") })
+          }
+        )
+      ]
+    }
+  ) });
+};
+bt.displayName = "DataTable.Header";
+const be = ({
+  ref: t,
+  children: e,
+  isDisabled: l,
+  ...n
+}) => {
+  const [o, i] = ke(n);
+  return /* @__PURE__ */ x(ai, { asChild: !0, ...o, children: /* @__PURE__ */ x(Xo, { ref: t, ...i, children: (r) => /* @__PURE__ */ x(Vt.Provider, { value: { isDisabled: l }, children: typeof e == "function" ? e(r) : e }) }) });
+};
+be.displayName = "DataTable.Cell";
+function lt(t) {
+  return t.target?.closest(
+    'button, input, [role="button"], [role="checkbox"], [slot="selection"], [data-slot="selection"]'
+  );
+}
+function yi(t) {
+  return t.target?.closest(
+    '[slot="selection"], [data-slot="selection"], [role="checkbox"]'
+  );
+}
+function Mt(t) {
+  const e = lt(t), l = yi(t);
+  (!e || e && !l) && t.stopPropagation();
+}
+const gt = ({
+  row: t,
+  ref: e,
+  ...l
+}) => {
+  const n = ie(ae), {
+    activeColumns: o,
+    search: i,
+    expanded: r,
+    toggleExpand: d,
+    nestedKey: s,
+    disabledKeys: u,
+    showExpandColumn: f,
+    showSelectionColumn: a,
+    isTruncated: p,
+    onRowClick: c,
+    onRowAction: m,
+    pinnedRows: h,
+    togglePin: g,
+    sortedRows: b
+  } = pe(), [y, v] = ke(l), $ = ((w) => u ? u === "all" || t.isDisabled ? !0 : u.has(w) : !1)(t.id), S = P(null), E = M(
+    (w) => {
+      if (!c) return;
+      const T = lt(w), V = window.getSelection()?.toString() !== void 0 && window.getSelection().toString().length > 0;
+      !T && !V && (S.current && window.clearTimeout(S.current), S.current = window.setTimeout(() => {
+        $ ? m && m(t, "click") : c(t), S.current = null;
+      }, 300));
+    },
+    [c, m, t, $]
+  ), B = M((w) => {
+    lt(w) || S.current && (window.clearTimeout(S.current), S.current = null);
+  }, []), R = P({
+    count: 0,
+    node: void 0
+  }), k = M(
+    (w) => {
+      R.current.count += 1, R.current.count === 1 && w && (R.current.node = w, w.addEventListener(
+        // Use pointerdown event in order to capture event before it bubbles to react-aria's onPress handler
+        "pointerdown",
+        Mt,
+        {
+          capture: !0
+        }
+      ), w.addEventListener("mouseup", E, { capture: !0 }), w.addEventListener("dblclick", B, {
+        capture: !0
+      }));
+    },
+    [E, B]
+  );
+  ce(() => () => {
+    S.current && (window.clearTimeout(S.current), S.current = null), R.current.count >= 1 && R.current.node && (R.current.node.removeEventListener(
+      "pointerdown",
+      Mt
+    ), R.current.node.removeEventListener("mouseup", E), R.current.node.removeEventListener(
+      "dblclick",
+      B
+    ));
+  }, [E, B]);
+  const N = Te(e, k), { selectionBehavior: H } = Hl(), O = s && t[s] && (Array.isArray(t[s]) ? t[s].length > 0 : !0), W = r[t.id], F = h.has(t.id), X = b.filter((w) => h.has(w.id)).map((w) => w.id), U = F ? X.indexOf(t.id) : -1, le = U === 0, he = U === X.length - 1, ne = X.length === 1 && F, _ = () => F ? ne ? "data-table-row-pinned-single" : le ? "data-table-row-pinned-first" : he ? "data-table-row-pinned-last" : "" : "", se = (w) => i && typeof w == "string" ? /* @__PURE__ */ x(_n, { query: i, ignoreCase: !0, matchAll: !0, children: w }) : w;
+  return /* @__PURE__ */ A(Ae, { children: [
+    /* @__PURE__ */ x(Kt, { asChild: !0, ...y, children: /* @__PURE__ */ A(
+      Bt,
+      {
+        isDisabled: $,
+        columns: o,
+        ref: N,
+        id: t.id,
+        className: `data-table-row ${$ ? "data-table-row-disabled" : ""} ${F ? `data-table-row-pinned ${_()}` : ""}`,
+        ...v,
+        dependencies: [W, i, p],
+        children: [
+          H === "toggle" && /* @__PURE__ */ x(
+            be,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "selection",
+              isDisabled: $,
+              children: /* @__PURE__ */ x(
+                oe,
+                {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  w: "100%",
+                  h: "100%",
+                  children: /* @__PURE__ */ x(
+                    Xt,
+                    {
+                      name: "select-row",
+                      slot: "selection",
+                      "aria-label": n.format("selectRow")
+                    }
+                  )
+                }
+              )
+            }
+          ),
+          f && /* @__PURE__ */ x(
+            be,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "expand",
+              isDisabled: $,
+              children: O ? /* @__PURE__ */ x(
+                Ul,
+                {
+                  w: "100%",
+                  h: "100%",
+                  cursor: "pointer",
+                  "aria-label": W ? "Collapse" : "Expand",
+                  onClick: (w) => {
+                    w.stopPropagation(), d(t.id);
+                  },
+                  children: W ? /* @__PURE__ */ x(en, {}) : /* @__PURE__ */ x(tn, {})
+                }
+              ) : null
+            }
+          ),
+          /* @__PURE__ */ x(Pe, { items: o, children: (w) => {
+            const T = w.accessor(t);
+            return /* @__PURE__ */ x(be, { isDisabled: $, children: /* @__PURE__ */ x(
+              oe,
+              {
+                className: p ? "truncated-cell" : "",
+                "data-truncated": p ? "true" : "false",
+                display: "inline-block",
+                h: "100%",
+                minW: "0",
+                maxW: "100%",
+                position: "relative",
+                overflow: "hidden",
+                cursor: $ ? "not-allowed" : "text",
+                children: w.render ? w.render({
+                  value: se(T),
+                  row: t,
+                  column: w
+                }) : se(T)
+              }
+            ) }, w.id);
+          } }),
+          /* @__PURE__ */ x(
+            be,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "pin-row-cell",
+              isDisabled: $,
+              children: /* @__PURE__ */ x(
+                oe,
+                {
+                  "data-slot": F ? "nimbus-table-cell-pin-button-pinned" : "nimbus-table-cell-pin-button",
+                  children: /* @__PURE__ */ A(Le.Root, { children: [
+                    /* @__PURE__ */ x(
+                      It,
+                      {
+                        size: "2xs",
+                        variant: "ghost",
+                        "aria-label": F ? "Unpin row" : "Pin row",
+                        colorPalette: "primary",
+                        onClick: (w) => {
+                          w.stopPropagation(), g(t.id);
+                        },
+                        children: /* @__PURE__ */ x(ln, {})
+                      },
+                      "pin-btn"
+                    ),
+                    /* @__PURE__ */ x(Le.Content, { placement: "top", children: F ? "Unpin row" : "Pin row" })
+                  ] })
+                }
+              )
+            }
+          )
+        ]
+      }
+    ) }),
+    f && /* @__PURE__ */ x(Kt, { ...y, asChild: !0, children: /* @__PURE__ */ x(
+      Bt,
+      {
+        "data-nested-row-expanded": W ? "true" : "false",
+        dependencies: [W],
+        children: /* @__PURE__ */ x(
+          be,
+          {
+            isDisabled: $,
+            colSpan: o.length + (f ? 1 : 0) + (a ? 1 : 0) + 1,
+            "data-nested-cell": !0,
+            children: W ? s && Array.isArray(t[s]) ? `${t[s].length} nested items` : s && t[s] : null
+          }
+        )
+      }
+    ) })
+  ] });
+};
+gt.displayName = "DataTable.Row";
+const $i = () => /* @__PURE__ */ x(oe, { w: "100%", p: "200", children: "No Data" }), vt = ({
+  ref: t,
+  "aria-label": e,
+  ...l
+}) => {
+  const n = ie(ae), { sortedRows: o, activeColumns: i, renderEmptyState: r } = pe(), [d, s] = ke(l), u = e ?? n.format("dataTableBody");
+  return /* @__PURE__ */ x(ri, { asChild: !0, ...d, children: /* @__PURE__ */ x(
+    Yo,
+    {
+      ref: t,
+      "aria-label": u,
+      items: o,
+      dependencies: [i],
+      renderEmptyState: r ?? $i,
+      ...s,
+      children: (f) => /* @__PURE__ */ x(gt, { row: f }, f.id)
+    }
+  ) });
+};
+vt.displayName = "DataTable.Body";
+const yt = function({
+  ref: e,
+  children: l,
+  ...n
+}) {
+  const o = P(null), i = Q(Te(o, e));
+  return /* @__PURE__ */ x(si, { ref: i, ...n, children: l });
+};
+yt.displayName = "DataTable.Footer";
+function xi(t) {
+  return "onRemoveItem" in t && typeof t.onRemoveItem == "function";
+}
+const Ci = ({
+  hiddenItems: t,
+  visibleItems: e,
+  handleVisibleColumnsUpdate: l,
+  handleResetColumns: n
+}) => {
+  const [o, i] = G(""), r = ie(ae);
+  if (!t || !e)
+    return null;
+  const d = K(() => t.filter(
+    (a) => a.label?.toString().toLowerCase().includes(o.toLowerCase())
+  ), [t, o]), s = (a) => {
+    i(a);
+  }, u = M(
+    (a) => {
+      const p = new Set(t.map((b) => b.id)), c = new Set(
+        a.map((b) => b.id)
+      ), m = t.filter(
+        (b) => !c.has(b.id)
+      ), h = a.filter(
+        (b) => !p.has(b.id)
+      );
+      let g = [...e];
+      if (m.length > 0 && (g = [...g, ...m]), h.length > 0) {
+        const b = new Set(h.map((y) => y.id));
+        g = g.filter(
+          (y) => !b.has(y.id)
+        );
+      }
+      l(g);
+    },
+    [t, e, l]
+  ), f = M(
+    (a) => {
+      l(a);
+    },
+    [l]
+  );
+  return /* @__PURE__ */ A(Ve, { mt: "800", children: [
+    /* @__PURE__ */ A(Ce, { gap: "400", width: "100%", columns: 2, children: [
+      /* @__PURE__ */ A(oe, { children: [
+        /* @__PURE__ */ A(Ve, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(nn, {}),
+          /* @__PURE__ */ x(Re, { fontWeight: "700", fontSize: "sm", w: "full", children: r.format("hiddenColumns") })
+        ] }),
+        /* @__PURE__ */ A(
+          Ve,
+          {
+            colorPalette: "primary",
+            border: "{sizes.25} solid",
+            borderColor: "colorPalette.3",
+            borderRadius: "200",
+            gap: "200",
+            p: "300",
+            h: "lg",
+            children: [
+              /* @__PURE__ */ x(
+                pn,
+                {
+                  w: "full",
+                  size: "sm",
+                  variant: "ghost",
+                  placeholder: r.format("searchHiddenColumns"),
+                  "aria-label": r.format("searchHiddenColumns"),
+                  onChange: s,
+                  value: o,
+                  "data-testid": "search-hidden-columns"
+                }
+              ),
+              /* @__PURE__ */ x(
+                Ft,
+                {
+                  colorPalette: "primary",
+                  border: "{sizes.25} solid",
+                  borderColor: "colorPalette.3"
+                }
+              ),
+              /* @__PURE__ */ x(
+                Ie.Root,
+                {
+                  border: "none",
+                  borderColor: "none",
+                  h: "full",
+                  w: "full",
+                  overflowY: "auto",
+                  items: d,
+                  onUpdateItems: u,
+                  "aria-label": r.format("hiddenColumnsAriaLabel"),
+                  "data-testid": "hidden-columns-list",
+                  renderEmptyState: /* @__PURE__ */ x(Re, { fontSize: "sm", color: "gray.9", children: r.format("noHiddenColumns") }),
+                  children: (a) => /* @__PURE__ */ x(
+                    Ie.Item,
+                    {
+                      py: "100",
+                      id: a.id,
+                      "aria-label": a.label?.toString() ?? a.id,
+                      children: a.label
+                    },
+                    a.id
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ A(oe, { children: [
+        /* @__PURE__ */ A(Ve, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(on, {}),
+          /* @__PURE__ */ x(Re, { fontWeight: "700", fontSize: "sm", children: r.format("visibleColumnsList") })
+        ] }),
+        /* @__PURE__ */ x(
+          Ie.Root,
+          {
+            removableItems: !0,
+            p: "300",
+            h: "lg",
+            overflowY: "auto",
+            items: e,
+            onUpdateItems: f,
+            "aria-label": r.format("visibleColumnsAria"),
+            "data-testid": "visible-columns-list",
+            children: (a) => /* @__PURE__ */ x(
+              Ie.Item,
+              {
+                py: "100",
+                id: a.id,
+                onRemoveItem: xi(a) ? a.onRemoveItem : void 0,
+                "aria-label": a.label?.toString() ?? a.id,
+                children: a.label
+              },
+              a.id
+            )
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ x(oe, { children: /* @__PURE__ */ A(
+      bn,
+      {
+        variant: "ghost",
+        colorPalette: "primary",
+        size: "xs",
+        onClick: n,
+        "aria-label": r.format("reset"),
+        children: [
+          /* @__PURE__ */ x(rn, {}),
+          r.format("reset")
+        ]
+      }
+    ) })
+  ] });
+}, Nt = {
+  TOGGLE_TEXT_VISIBILITY: "toggleTextVisibility",
+  TOGGLE_ROW_DENSITY: "toggleRowDensity"
+}, wi = ({
+  onSettingsChange: t
+}) => {
+  const e = ie(ae), l = pe(), n = l.isTruncated ?? !1, o = l.density === "condensed" ? "compact" : "comfortable", i = (d) => {
+    Array.from(d)[0] && t?.(Nt.TOGGLE_TEXT_VISIBILITY);
+  }, r = (d) => {
+    Array.from(d)[0] && t?.(Nt.TOGGLE_ROW_DENSITY);
+  };
+  return /* @__PURE__ */ A(
+    Ce,
+    {
+      templateColumns: "repeat(4, 1fr)",
+      columnGap: "400",
+      rowGap: "600",
+      mt: "800",
+      alignItems: "center",
+      children: [
+        /* @__PURE__ */ x(Ce.Item, { colSpan: 1, children: /* @__PURE__ */ x(Re, { fontWeight: "500", children: e.format("textVisibility") }) }),
+        /* @__PURE__ */ x(Ce.Item, { colSpan: 3, children: /* @__PURE__ */ x(St, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Et.Root,
+          {
+            w: "full",
+            selectedKeys: n ? ["preview"] : ["full"],
+            onSelectionChange: i,
+            "aria-label": e.format("textVisibilityAriaLabel"),
+            children: [
+              /* @__PURE__ */ A(
+                He,
+                {
+                  id: "full",
+                  size: "xs",
+                  "aria-label": e.format("fullText"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(an, {}),
+                    e.format("fullText")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                He,
+                {
+                  id: "preview",
+                  size: "xs",
+                  "aria-label": e.format("textPreviews"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(sn, {}),
+                    e.format("textPreviews")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) }),
+        /* @__PURE__ */ x(Ce.Item, { colSpan: 1, children: /* @__PURE__ */ x(Re, { fontWeight: "500", children: e.format("rowDensity") }) }),
+        /* @__PURE__ */ x(Ce.Item, { colSpan: 3, children: /* @__PURE__ */ x(St, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Et.Root,
+          {
+            w: "full",
+            colorPalette: "primary",
+            selectedKeys: [o],
+            onSelectionChange: r,
+            "aria-label": e.format("rowDensityAriaLabel"),
+            children: [
+              /* @__PURE__ */ A(
+                He,
+                {
+                  id: "comfortable",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("comfortable"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(un, {}),
+                    e.format("comfortable")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                He,
+                {
+                  id: "compact",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("compact"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(dn, {}),
+                    e.format("compact")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) })
+      ]
+    }
+  );
+}, ql = () => {
+  const [t, e] = G(!1), l = pe(), n = ie(ae), {
+    columns: o,
+    visibleColumns: i,
+    onColumnsChange: r,
+    onSettingsChange: d
+    // customSettings,
+  } = l, s = o.filter(
+    (y) => !i?.includes(y.id)
+  ), { customSettings: u } = mi(), f = P(o);
+  ce(() => {
+    f.current = o;
+  }, [o]);
+  const a = P(o), p = P(i), c = P(i || []);
+  if (!i || !s)
+    return null;
+  const m = K(() => (y) => {
+    const v = y.map((E) => E.id);
+    if (!(v.length !== c.current.length || v.some(
+      (E, B) => E !== c.current[B]
+    )))
+      return;
+    const $ = new Map(f.current.map((E) => [E.id, E])), S = y.map((E) => $.get(E.id)).filter(
+      (E) => E !== void 0
+    );
+    c.current = v, r && r(S);
+  }, []), h = K(() => o.filter((y) => !i?.includes(y.id)).map((y) => ({
+    key: y.id,
+    id: y.id,
+    label: y.header
+  })), [i, o]), g = K(() => {
+    if (!i || i.length === 0)
+      return [];
+    const y = new Map(o.map((v) => [v.id, v]));
+    return i.map((v) => {
+      const C = y.get(v);
+      return C ? {
+        key: C.id,
+        id: C.id,
+        label: C.header
+      } : null;
+    }).filter((v) => v !== null);
+  }, [o, i]), b = M(() => {
+    if (r) {
+      const y = p.current;
+      if (y && y.length > 0) {
+        const v = new Map(
+          a.current.map(($) => [$.id, $])
+        ), C = y.map(($) => v.get($)).filter(
+          ($) => $ !== void 0
+        );
+        c.current = y, r(C);
+      } else
+        c.current = a.current.map(
+          (v) => v.id
+        ), r(a.current);
+    }
+  }, [r]);
+  return /* @__PURE__ */ A(Ae, { children: [
+    /* @__PURE__ */ A(Le.Root, { children: [
+      /* @__PURE__ */ x(Le.Content, { placement: "top", children: n.format("settings") }),
+      /* @__PURE__ */ x(
+        It,
+        {
+          variant: "ghost",
+          colorPalette: "primary",
+          size: "xs",
+          "aria-label": n.format("settings"),
+          onClick: () => e(!0),
+          children: /* @__PURE__ */ x(cn, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ x(
+      ye.Root,
+      {
+        isOpen: t,
+        onOpenChange: e,
+        placement: "right",
+        "data-testid": "data-table-manager-drawer",
+        children: /* @__PURE__ */ A(
+          ye.Content,
+          {
+            width: "2xl",
+            "data-testid": "data-table-manager-drawer",
+            "aria-label": n.format("settings"),
+            children: [
+              /* @__PURE__ */ A(ye.Header, { children: [
+                /* @__PURE__ */ x(ye.Title, { children: n.format("settings") }),
+                /* @__PURE__ */ x(ye.CloseTrigger, {})
+              ] }),
+              /* @__PURE__ */ x(ye.Body, { children: /* @__PURE__ */ x(
+                gn.Root,
+                {
+                  tabListAriaLabel: n.format("settingsTabsAriaLabel"),
+                  tabs: [
+                    {
+                      id: "visible-columns",
+                      tabLabel: /* @__PURE__ */ A(Ae, { children: [
+                        /* @__PURE__ */ x(fn, {}),
+                        n.format("visibleColumns")
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(
+                        Ci,
+                        {
+                          hiddenItems: h,
+                          visibleItems: g,
+                          handleVisibleColumnsUpdate: m,
+                          handleResetColumns: b
+                        }
+                      )
+                    },
+                    {
+                      id: "layout-settings",
+                      tabLabel: /* @__PURE__ */ A(Ae, { children: [
+                        /* @__PURE__ */ x(mn, {}),
+                        n.format("layoutSettings")
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(wi, { onSettingsChange: d })
+                    },
+                    u ? {
+                      id: "custom-settings",
+                      tabLabel: /* @__PURE__ */ A(Ae, { children: [
+                        u?.icon ?? null,
+                        u?.label
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(oe, { mt: "800", children: u.panel })
+                    } : null
+                    // Filter out null values when no custom settings are provided
+                  ].filter((y) => y !== null)
+                }
+              ) })
+            ]
+          }
+        )
+      }
+    )
+  ] });
+};
+ql.displayName = "DataTable.Manager";
+const Di = function({
+  ref: e,
+  footer: l,
+  ...n
+}) {
+  const o = ie(ae), i = P(null), r = Q(Te(i, e));
+  return /* @__PURE__ */ A(pt, { ref: r, ...n, children: [
+    /* @__PURE__ */ A(ht, { "aria-label": o.format("dataTable"), children: [
+      /* @__PURE__ */ x(bt, { "aria-label": o.format("dataTableHeader") }),
+      /* @__PURE__ */ x(vt, { "aria-label": o.format("dataTableBody") })
+    ] }),
+    l && /* @__PURE__ */ x(yt, { children: l })
+  ] });
+}, Kr = /* @__PURE__ */ Object.assign(Di, {
+  /**
+   * # DataTable.Root
+   *
+   * The root container that provides context and state management for the entire data table.
+   * Handles data processing, sorting, filtering, selection, and expansion state.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows} allowsSorting>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Root: pt,
+  /**
+   * # DataTable.Table
+   *
+   * The main table element that wraps the header and body components.
+   * Provides the semantic HTML table structure with React Aria table behavior.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Table: ht,
+  /**
+   * # DataTable.Header
+   *
+   * The table header section that renders column headers with sorting capabilities.
+   * Automatically generates columns based on the configuration provided to Root.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Header: bt,
+  /**
+   * # DataTable.Column
+   *
+   * Individual column header component that handles sorting interactions and displays column content.
+   * Used internally by Header but can be used for custom header implementations.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header>
+   *       <DataTable.Column column={customColumn} />
+   *     </DataTable.Header>
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Column: we,
+  /**
+   * # DataTable.Body
+   *
+   * The table body section that renders all data rows with selection and expansion capabilities.
+   * Handles empty states and provides accessibility features for row navigation.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Body: vt,
+  /**
+   * # DataTable.Row
+   *
+   * Individual row component that renders data cells and handles row-level interactions.
+   * Supports selection, expansion, and click handlers for custom row actions.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body>
+   *       <DataTable.Row row={customRow} />
+   *     </DataTable.Body>
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Row: gt,
+  /**
+   * # DataTable.Cell
+   *
+   * Individual cell component that displays data values with proper accessibility attributes.
+   * Supports custom rendering and truncation based on table configuration.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body>
+   *       <DataTable.Row>
+   *         <DataTable.Cell>Custom cell content</DataTable.Cell>
+   *       </DataTable.Row>
+   *     </DataTable.Body>
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Cell: be,
+  /**
+   * # DataTable.Footer
+   *
+   * Optional footer section for displaying summary information, pagination, or actions.
+   * Positioned below the table with proper styling integration.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   *   <DataTable.Footer>
+   *     <Pagination />
+   *   </DataTable.Footer>
+   * </DataTable.Root>
+   * ```
+   */
+  Footer: yt,
+  /**
+   * # DataTable.Manager
+   *
+   * A settings panel that allows users to manage table columns visibility and layout.
+   * Opens in a drawer with tabs for "Visible columns" and "Layout settings".
+   * Uses drag-and-drop to reorder columns.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Manager />
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Manager: ql,
+  /**
+   * # DataTable.ExpandButton
+   *
+   * Button component for expanding/collapsing nested rows in hierarchical data.
+   * Automatically shown when data contains nested structures.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.ExpandButton
+   *   isExpanded={expanded}
+   *   onPress={() => toggleExpand(rowId)}
+   * />
+   * ```
+   */
+  ExpandButton: Ul,
+  /**
+   * # DataTable.NestedIcon
+   *
+   * Icon component that indicates the nesting level and expansion state of hierarchical rows.
+   * Provides visual hierarchy cues for nested data structures.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.NestedIcon
+   *   depth={2}
+   *   isExpanded={expanded}
+   *   hasChildren={hasChildren}
+   * />
+   * ```
+   */
+  NestedIcon: di,
+  /**
+   * # DataTable.SelectionCell
+   *
+   * Specialized cell component that contains selection checkboxes or radio buttons.
+   * Handles row selection state and provides accessible selection controls.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.SelectionCell
+   *   isSelected={selected}
+   *   onSelectionChange={handleSelection}
+   * />
+   * ```
+   */
+  SelectionCell: ui,
+  /**
+   * # DataTable.Context
+   *
+   * React context that provides shared state and configuration to all table components.
+   * Used internally for component coordination - not typically used directly.
+   *
+   * @example
+   * ```tsx
+   * const context = useContext(DataTable.Context);
+   * ```
+   */
+  Context: qe,
+  /**
+   * # DataTable.useDataTableContext
+   *
+   * Hook that provides access to the DataTable context with proper error handling.
+   * Throws an error if used outside of a DataTable.Root provider.
+   *
+   * @example
+   * ```tsx
+   * const { columns, rows, sortDescriptor } = DataTable.useDataTableContext();
+   * ```
+   */
+  useDataTableContext: pe
+});
+export {
+  Kr as D,
+  Nt as U,
+  vt as a,
+  be as b,
+  we as c,
+  Ul as d,
+  yt as e,
+  bt as f,
+  ql as g,
+  di as h,
+  pt as i,
+  gt as j,
+  ui as k,
+  ht as l
+};
+//# sourceMappingURL=data-table-CKhJ_ujL.es.js.map