@commercetools/nimbus 2.5.0 → 2.7.0

package/dist/chunks/data-table-DlcR-8aA.es.js

@@ -0,0 +1,4440 @@
+import { jsx as x, jsxs as A, Fragment as Re } from "react/jsx-runtime";
+import D, { useRef as P, useCallback as M, useState as Z, useMemo as K, useEffect as fe, useContext as z, forwardRef as J, createContext as pe } from "react";
+import { createSlotRecipeContext as nn, mergeRefs as Pe } from "@chakra-ui/react";
+import { n as ze, u as ie } from "./normalize-messages-BN9BAFXe.es.js";
+import { ArrowDownward as on, KeyboardArrowDown as rn, KeyboardArrowRight as an, PushPin as sn, VisibilityOff as un, Visibility as dn, Refresh as cn, WrapText as fn, ShortText as pn, DensitySmall as mn, FormatAlignJustify as hn, Settings as bn, ViewWeek as gn, ViewDay as vn } from "@commercetools/nimbus-icons";
+import { S as xe } from "./simple-grid-DU5v66TG.es.js";
+import { S as yn } from "./search-input-5e2zcgNd.es.js";
+import { $ as $n, D as Le } from "./draggable-list-BHsqT_Jr.es.js";
+import { S as Oe } from "./stack-CoNreM7B.es.js";
+import { B as oe } from "./box-DuBoAZvq.es.js";
+import { T as Te } from "./text-61Btuuxn.es.js";
+import { S as Lt } from "./separator-CU4JgqNT.es.js";
+import { B as xn } from "./button-CoAqYH5C.es.js";
+import { I as je } from "./icon-toggle-button-YtpVxus0.es.js";
+import { T as At } from "./toolbar-Clh1EbKK.es.js";
+import { T as Tt } from "./toggle-button-group-PnfISweU.es.js";
+import { D as ve } from "./drawer-BT6HuA73.es.js";
+import { T as Cn } from "./tabs-ZyrURnl1.es.js";
+import { T as Ge } from "./tooltip-DsIxtZs4.es.js";
+import { I as nt } from "./icon-button-BP-AkGEm.es.js";
+import { $ as Q } from "./useObjectRef-CaJ5pgjX.es.js";
+import { $ as Ot } from "./Button-DdJe0Bsx.es.js";
+import { a as jt, b as Pt, c as wn } from "./RSPContexts-DLgb84PF.es.js";
+import { a as me, b as I, $ as Ut, e as qe, g as Bt } from "./utils-CiIOoh_a.es.js";
+import { f as W, m as ce, n as de, o as Ue, e as Dn, g as Gt, $ as Yt, b as Sn, a as En, h as V, j as Xt } from "./SelectionManager-CKL0m64P.es.js";
+import { e as Se, g as kn, f as zn, h as Rn, i as _i } from "./ListBox-B1XPvV-u.es.js";
+import { $ as An } from "./intlStrings-Cd44R5hT.es.js";
+import { a as Tn, $ as Pn } from "./SelectionIndicator-B27AsfqE.es.js";
+import { c as ut, i as Bn, g as Be, f as Kn, j as Mn, a as Ze, $ as qt, k as Nn, h as nr } from "./CollectionBuilder-0GDhYLYj.es.js";
+import { c as ot, $ as dt, a as j, e as Fn, b as In } from "./mergeProps-Dg8WqJiN.es.js";
+import { $ as ee } from "./filterDOMProps-Cxz9cAAv.es.js";
+import { a as Vn } from "./OverlayArrow-Dk149xUz.es.js";
+import { c as ye, a as ct, $ as Hn } from "./scrollIntoView-BusXP5qP.es.js";
+import { b as ur } from "./useListState-xdP8vTga.es.js";
+import Wn from "react-dom";
+import { $ as Ke } from "./useHover-Y3jiyL7C.es.js";
+import { a as Je, $ as Kt } from "./VisuallyHidden-B84WBioE.es.js";
+import { $ as Mt, k as Ln } from "./openLink-HsZR1nGD.es.js";
+import { $ as we, m as Ye } from "./utils-_TS1FtP1.es.js";
+import { $ as Ee } from "./context-BfHy4NgG.es.js";
+import { $ as De } from "./useFocusRing-BMbyOrJt.es.js";
+import { a as Nt, b as On } from "./FocusScope-uL2GkoJc.es.js";
+import { $ as Me } from "./useLocalizedStringFormatter-CYDf7GZk.es.js";
+import { a as jn, b as Un, $ as Zt } from "./usePress-qb58ZN-U.es.js";
+import { $ as Gn, c as Yn } from "./useFocusable-hSEKBu4u.es.js";
+import { $ as Xn, f as qn } from "./useFocusVisible-BYry1gSZ.es.js";
+import { $ as _ } from "./focusSafely-CCta_Ygk.es.js";
+import { $ as $e } from "./getScrollParent-Bf02nsKW.es.js";
+import { $ as Zn } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { $ as it } from "./useEffectEvent-BqXYahDg.es.js";
+import { e as Jn, c as Qn } from "./Header-DtejjUvp.es.js";
+import { $ as _n } from "./LiveAnnouncer-CsPyaceH.es.js";
+import { d as eo, e as to } from "./useGridListItem-VfYU11P8.es.js";
+import { $ as Jt } from "./useCollator-DKdD8vEj.es.js";
+import { $ as lo } from "./useHasTabbableChild-MKRDwhdr.es.js";
+import { $ as no } from "./useUpdateEffect-DlZlnK9P.es.js";
+import { e as ke } from "./extract-style-props-DycRTKUw.es.js";
+import { Highlight as oo } from "@chakra-ui/react/highlight";
+import { C as Qt } from "./checkbox-F_Hv9VwU.es.js";
+import { F as io } from "./flex-BqxAMF-7.es.js";
+function ro(t) {
+  let { onMoveStart: e, onMove: l, onMoveEnd: n } = t, o = P({
+    didMove: !1,
+    lastPosition: null,
+    id: null
+  }), { addGlobalListener: i, removeGlobalListener: r } = Zn(), d = M((p, h, g, b) => {
+    g === 0 && b === 0 || (o.current.didMove || (o.current.didMove = !0, e?.({
+      type: "movestart",
+      pointerType: h,
+      shiftKey: p.shiftKey,
+      metaKey: p.metaKey,
+      ctrlKey: p.ctrlKey,
+      altKey: p.altKey
+    })), l?.({
+      type: "move",
+      pointerType: h,
+      deltaX: g,
+      deltaY: b,
+      shiftKey: p.shiftKey,
+      metaKey: p.metaKey,
+      ctrlKey: p.ctrlKey,
+      altKey: p.altKey
+    }));
+  }, [
+    e,
+    l,
+    o
+  ]), s = it(d), u = M((p, h) => {
+    jn(), o.current.didMove && n?.({
+      type: "moveend",
+      pointerType: h,
+      shiftKey: p.shiftKey,
+      metaKey: p.metaKey,
+      ctrlKey: p.ctrlKey,
+      altKey: p.altKey
+    });
+  }, [
+    n,
+    o
+  ]), f = it(u), [a, m] = Z(null);
+  return ot(() => {
+    if (a === "pointer") {
+      let p = (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", p, !1), r(window, "pointerup", h, !1), r(window, "pointercancel", h, !1), m(null);
+        }
+      };
+      return i(window, "pointermove", p, !1), i(window, "pointerup", h, !1), i(window, "pointercancel", h, !1), () => {
+        r(window, "pointermove", p, !1), r(window, "pointerup", h, !1), r(window, "pointercancel", h, !1);
+      };
+    } else if (a === "mouse" && process.env.NODE_ENV === "test") {
+      let p = (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", p, !1), r(window, "mouseup", h, !1), m(null));
+      };
+      return i(window, "mousemove", p, !1), i(window, "mouseup", h, !1), () => {
+        r(window, "mousemove", p, !1), r(window, "mouseup", h, !1);
+      };
+    } else if (a === "touch" && process.env.NODE_ENV === "test") {
+      let p = (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", p), r(window, "touchend", h), r(window, "touchcancel", h), m(null));
+      };
+      return i(window, "touchmove", p, !1), i(window, "touchend", h, !1), i(window, "touchcancel", h, !1), () => {
+        r(window, "touchmove", p, !1), r(window, "touchend", h, !1), r(window, "touchcancel", h, !1);
+      };
+    }
+  }, [
+    a,
+    i,
+    r
+  ]), {
+    moveProps: K(() => {
+      let p = {}, h = () => {
+        Un(), o.current.didMove = !1;
+      };
+      typeof PointerEvent > "u" && process.env.NODE_ENV === "test" ? (p.onMouseDown = (b) => {
+        b.button === 0 && (h(), b.stopPropagation(), b.preventDefault(), o.current.lastPosition = {
+          pageX: b.pageX,
+          pageY: b.pageY
+        }, m("mouse"));
+      }, p.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, m("touch");
+      }) : p.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, m("pointer"));
+      };
+      let g = (b, y, v) => {
+        h(), d(b, "keyboard", y, v), u(b, "keyboard");
+      };
+      return p.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;
+        }
+      }, p;
+    }, [
+      o,
+      d,
+      u
+    ])
+  };
+}
+class _t {
+  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 W(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 = W(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = ce(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 = W(f, this.collection);
+      var r;
+      let m = (r = this.direction === "rtl" ? Ue(a, l.index - 1) : Ue(a, l.index + 1)) !== null && r !== void 0 ? r : null;
+      var d;
+      if (m) return (d = m.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 = W(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = de(f)) === null || n === void 0 ? void 0 : n.key : (o = ce(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 = W(f, this.collection);
+      var r;
+      let m = (r = this.direction === "rtl" ? Ue(a, l.index + 1) : Ue(a, l.index - 1)) !== null && r !== void 0 ? r : null;
+      var d;
+      if (m) return (d = m.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 = de(W(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 = de(W(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 = W(u, this.collection);
+        var r;
+        return (r = (i = ce(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 = W(u, this.collection);
+      var s;
+      n = (s = (d = ce(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 = de(W(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 ao(e.layout) : new Jn(e.ref));
+    var l;
+    this.focusMode = (l = e.focusMode) !== null && l !== void 0 ? l : "row";
+  }
+}
+class ao {
+  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 ft = /* @__PURE__ */ new WeakMap();
+function so(t, e, l) {
+  let { isVirtualized: n, disallowTypeAhead: o, keyboardDelegate: i, focusMode: r, scrollRef: d, getRowText: s, onRowAction: u, onCellAction: f, escapeKeyBehavior: a = "clearSelection", shouldSelectOnPressUp: m } = t, { selectionManager: c } = e;
+  !t["aria-label"] && !t["aria-labelledby"] && console.warn("An aria-label or aria-labelledby prop is required for accessibility.");
+  let p = Jt({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: h } = Ee(), g = e.selectionManager.disabledBehavior, b = K(() => i || new _t({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: g,
+    ref: l,
+    direction: h,
+    collator: p,
+    focusMode: r
+  }), [
+    i,
+    e.collection,
+    e.disabledKeys,
+    g,
+    l,
+    h,
+    p,
+    r
+  ]), { collectionProps: y } = Dn({
+    ref: l,
+    selectionManager: c,
+    keyboardDelegate: b,
+    isVirtualized: n,
+    scrollRef: d,
+    disallowTypeAhead: o,
+    escapeKeyBehavior: a
+  }), v = dt(t.id);
+  ft.set(e, {
+    keyboardDelegate: b,
+    actions: {
+      onRowAction: u,
+      onCellAction: f
+    },
+    shouldSelectOnPressUp: m
+  });
+  let C = eo({
+    selectionManager: c,
+    hasItemActions: !!(u || f)
+  }), $ = ee(t, {
+    labelable: !0
+  }), S = M((k) => {
+    if (c.isFocused) {
+      we(k.currentTarget, k.target) || c.setFocused(!1);
+      return;
+    }
+    we(k.currentTarget, k.target) && c.setFocused(!0);
+  }, [
+    c
+  ]), E = K(() => ({
+    onBlur: y.onBlur,
+    onFocus: S
+  }), [
+    S,
+    y.onBlur
+  ]), B = lo(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), to({
+    getRowText: s
+  }, e), {
+    gridProps: R
+  };
+}
+function uo() {
+  return {
+    rowGroupProps: {
+      role: "rowgroup"
+    }
+  };
+}
+function co(t, e, l) {
+  var n, o;
+  let { node: i, isVirtualized: r, shouldSelectOnPressUp: d, onAction: s } = t, { actions: u, shouldSelectOnPressUp: f } = ft.get(e), a = u.onRowAction ? () => {
+    var g;
+    return (g = u.onRowAction) === null || g === void 0 ? void 0 : g.call(u, i.key);
+  } : s, { itemProps: m, ...c } = Gt({
+    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 ? Fn(i == null || (o = i.props) === null || o === void 0 ? void 0 : o.onAction, a) : void 0,
+    isDisabled: e.collection.size === 0
+  }), p = e.selectionManager.isSelected(i.key), h = {
+    role: "row",
+    "aria-selected": e.selectionManager.selectionMode !== "none" ? p : void 0,
+    "aria-disabled": c.isDisabled || void 0,
+    ...m
+  };
+  return r && (h["aria-rowindex"] = i.index + 1), {
+    rowProps: h,
+    ...c
+  };
+}
+function el(t, e, l) {
+  let { node: n, isVirtualized: o, focusMode: i = "child", shouldSelectOnPressUp: r, onAction: d } = t, { direction: s } = Ee(), { keyboardDelegate: u, actions: { onCellAction: f } } = ft.get(e), a = P(null), m = () => {
+    if (l.current) {
+      let v = Nt(l.current);
+      if (i === "child") {
+        if (we(l.current, document.activeElement) && l.current !== document.activeElement) return;
+        let C = e.selectionManager.childFocusStrategy === "last" ? lt(v) : v.firstChild();
+        if (C) {
+          _(C);
+          return;
+        }
+      }
+      (a.current != null && n.key !== a.current || !we(l.current, document.activeElement)) && _(l.current);
+    }
+  }, { itemProps: c, isPressed: p } = Gt({
+    selectionManager: e.selectionManager,
+    key: n.key,
+    ref: l,
+    isVirtualized: o,
+    focus: m,
+    shouldSelectOnPressUp: r,
+    onAction: f ? () => f(n.key) : d,
+    isDisabled: e.collection.size === 0
+  }), h = (v) => {
+    if (!we(v.currentTarget, v.target) || e.isKeyboardNavigationDisabled || !l.current || !document.activeElement) return;
+    let C = Nt(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)
+          _(k), ye(k, {
+            containingElement: $e(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" ? (_(l.current), ye(l.current, {
+            containingElement: $e(l.current)
+          })) : (C.currentNode = l.current, k = s === "rtl" ? C.firstChild() : lt(C), k && (_(k), ye(k, {
+            containingElement: $e(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)
+          _(k), ye(k, {
+            containingElement: $e(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" ? (_(l.current), ye(l.current, {
+            containingElement: $e(l.current)
+          })) : (C.currentNode = l.current, k = s === "rtl" ? lt(C) : C.firstChild(), k && (_(k), ye(k, {
+            containingElement: $e(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowUp":
+      case "ArrowDown":
+        if (!v.altKey && we(l.current, 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) {
+      Xn() || e.selectionManager.setFocusedKey(n.key);
+      return;
+    }
+    requestAnimationFrame(() => {
+      i === "child" && document.activeElement === l.current && m();
+    });
+  }, 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: p
+  };
+}
+function lt(t) {
+  let e = null, l = null;
+  do
+    l = t.lastChild(), l && (e = l);
+  while (l);
+  return e;
+}
+const pt = /* @__PURE__ */ new WeakMap();
+function rt(t) {
+  return typeof t == "string" ? t.replace(/\s*/g, "") : "" + t;
+}
+function tl(t, e) {
+  let l = pt.get(t);
+  if (!l) throw new Error("Unknown grid");
+  return `${l}-${rt(e)}`;
+}
+function ll(t, e, l) {
+  let n = pt.get(t);
+  if (!n) throw new Error("Unknown grid");
+  return `${n}-${rt(e)}-${rt(l)}`;
+}
+function nl(t, e) {
+  return [
+    ...t.collection.rowHeaderColumnKeys
+  ].map((l) => ll(t, e, l)).join(" ");
+}
+var ol = {};
+ol = {
+  ascending: "تصاعدي",
+  ascendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تصاعدي`,
+  columnSize: (t) => `${t.value} بالبكسل`,
+  descending: "تنازلي",
+  descendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تنازلي`,
+  resizerDescription: "اضغط على مفتاح Enter لبدء تغيير الحجم",
+  select: "تحديد",
+  selectAll: "تحديد الكل",
+  sortable: "عمود قابل للترتيب"
+};
+var il = {};
+il = {
+  ascending: "възходящ",
+  ascendingSort: (t) => `сортирано по колона ${t.columnName} във възходящ ред`,
+  columnSize: (t) => `${t.value} пиксела`,
+  descending: "низходящ",
+  descendingSort: (t) => `сортирано по колона ${t.columnName} в низходящ ред`,
+  resizerDescription: "Натиснете „Enter“, за да започнете да преоразмерявате",
+  select: "Изберете",
+  selectAll: "Изберете всичко",
+  sortable: "сортираща колона"
+};
+var rl = {};
+rl = {
+  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 al = {};
+al = {
+  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 sl = {};
+sl = {
+  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 ul = {};
+ul = {
+  ascending: "αύξουσα",
+  ascendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε αύξουσα σειρά`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "φθίνουσα",
+  descendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε φθίνουσα σειρά`,
+  resizerDescription: "Πατήστε Enter για έναρξη της αλλαγής μεγέθους",
+  select: "Επιλογή",
+  selectAll: "Επιλογή όλων",
+  sortable: "Στήλη διαλογής"
+};
+var dl = {};
+dl = {
+  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 cl = {};
+cl = {
+  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 fl = {};
+fl = {
+  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 pl = {};
+pl = {
+  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 ml = {};
+ml = {
+  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 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: "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 gl = {};
+gl = {
+  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 vl = {};
+vl = {
+  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 yl = {};
+yl = {
+  ascending: "昇順",
+  ascendingSort: (t) => `列 ${t.columnName} を昇順で並べ替え`,
+  columnSize: (t) => `${t.value} ピクセル`,
+  descending: "降順",
+  descendingSort: (t) => `列 ${t.columnName} を降順で並べ替え`,
+  resizerDescription: "Enter キーを押してサイズ変更を開始",
+  select: "選択",
+  selectAll: "すべて選択",
+  sortable: "並べ替え可能な列"
+};
+var $l = {};
+$l = {
+  ascending: "오름차순",
+  ascendingSort: (t) => `${t.columnName} 열을 기준으로 오름차순으로 정렬됨`,
+  columnSize: (t) => `${t.value} 픽셀`,
+  descending: "내림차순",
+  descendingSort: (t) => `${t.columnName} 열을 기준으로 내림차순으로 정렬됨`,
+  resizerDescription: "크기 조정을 시작하려면 Enter를 누르세요.",
+  select: "선택",
+  selectAll: "모두 선택",
+  sortable: "정렬 가능한 열"
+};
+var xl = {};
+xl = {
+  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 Cl = {};
+Cl = {
+  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 wl = {};
+wl = {
+  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 Dl = {};
+Dl = {
+  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 Sl = {};
+Sl = {
+  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 El = {};
+El = {
+  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 kl = {};
+kl = {
+  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 zl = {};
+zl = {
+  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 Rl = {};
+Rl = {
+  ascending: "возрастание",
+  ascendingSort: (t) => `сортировать столбец ${t.columnName} в порядке возрастания`,
+  columnSize: (t) => `${t.value} пикс.`,
+  descending: "убывание",
+  descendingSort: (t) => `сортировать столбец ${t.columnName} в порядке убывания`,
+  resizerDescription: "Нажмите клавишу Enter для начала изменения размеров",
+  select: "Выбрать",
+  selectAll: "Выбрать все",
+  sortable: "сортируемый столбец"
+};
+var Al = {};
+Al = {
+  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 Tl = {};
+Tl = {
+  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 Pl = {};
+Pl = {
+  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 Bl = {};
+Bl = {
+  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 Kl = {};
+Kl = {
+  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 Ml = {};
+Ml = {
+  ascending: "висхідний",
+  ascendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у висхідному порядку`,
+  columnSize: (t) => `${t.value} пікс.`,
+  descending: "низхідний",
+  descendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у низхідному порядку`,
+  resizerDescription: "Натисніть Enter, щоб почати зміну розміру",
+  select: "Вибрати",
+  selectAll: "Вибрати все",
+  sortable: "сортувальний стовпець"
+};
+var Nl = {};
+Nl = {
+  ascending: "升序",
+  ascendingSort: (t) => `按列 ${t.columnName} 升序排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "降序",
+  descendingSort: (t) => `按列 ${t.columnName} 降序排序`,
+  resizerDescription: "按“输入”键开始调整大小。",
+  select: "选择",
+  selectAll: "全选",
+  sortable: "可排序的列"
+};
+var Fl = {};
+Fl = {
+  ascending: "遞增",
+  ascendingSort: (t) => `已依據「${t.columnName}」欄遞增排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "遞減",
+  descendingSort: (t) => `已依據「${t.columnName}」欄遞減排序`,
+  resizerDescription: "按 Enter 鍵以開始調整大小",
+  select: "選取",
+  selectAll: "全選",
+  sortable: "可排序的欄"
+};
+var Ne = {};
+Ne = {
+  "ar-AE": ol,
+  "bg-BG": il,
+  "cs-CZ": rl,
+  "da-DK": al,
+  "de-DE": sl,
+  "el-GR": ul,
+  "en-US": dl,
+  "es-ES": cl,
+  "et-EE": fl,
+  "fi-FI": pl,
+  "fr-FR": ml,
+  "he-IL": hl,
+  "hr-HR": bl,
+  "hu-HU": gl,
+  "it-IT": vl,
+  "ja-JP": yl,
+  "ko-KR": $l,
+  "lt-LT": xl,
+  "lv-LV": Cl,
+  "nb-NO": wl,
+  "nl-NL": Dl,
+  "pl-PL": Sl,
+  "pt-BR": El,
+  "pt-PT": kl,
+  "ro-RO": zl,
+  "ru-RU": Rl,
+  "sk-SK": Al,
+  "sl-SI": Tl,
+  "sr-SP": Pl,
+  "sv-SE": Bl,
+  "tr-TR": Kl,
+  "uk-UA": Ml,
+  "zh-CN": Nl,
+  "zh-TW": Fl
+};
+class fo extends _t {
+  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 = de(W(l, this.collection));
+      if (n) return n.key;
+      let o = this.getFirstKey();
+      return o == null || !this.collection.getItem(o) ? null : super.getKeyForItemInRowByIndex(o, l.index);
+    }
+    return super.getKeyBelow(e);
+  }
+  getKeyAbove(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (l.type === "column") {
+      let 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 W(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 = [
+      ...W(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 W(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 m = l != null ? n.getItem(l) : i;
+            return m?.type === "cell" ? u.key : s.key;
+          }
+        }
+      }
+      o = this.getKeyBelow(o), o == null && !d && (o = this.getFirstKey(), d = !0);
+    }
+    return null;
+  }
+}
+function po(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function mo(t, e, l) {
+  let { keyboardDelegate: n, isVirtualized: o, layoutDelegate: i, layout: r } = t, d = Jt({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: s } = Ee(), u = e.selectionManager.disabledBehavior, f = K(() => n || new fo({
+    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 = dt(t.id);
+  pt.set(e, a);
+  let { gridProps: m } = so({
+    ...t,
+    id: a,
+    keyboardDelegate: f
+  }, e, l);
+  o && (m["aria-rowcount"] = e.collection.size + e.collection.headerRows.length), Ye() && "expandedKeys" in e && (m.role = "treegrid");
+  let { column: c, direction: p } = e.sortDescriptor || {}, h = Me(po(Ne), "@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 p && c ? h.format(`${p}Sort`, {
+      columnName: C
+    }) : void 0;
+  }, [
+    p,
+    c,
+    e.collection.columns
+  ]), b = ct(g);
+  return no(() => {
+    g && _n(g, "assertive", 500);
+  }, [
+    g
+  ]), {
+    gridProps: j(m, b, {
+      // merge sort description with long press information
+      "aria-describedby": [
+        b["aria-describedby"],
+        m["aria-describedby"]
+      ].filter(Boolean).join(" ")
+    })
+  };
+}
+function ho(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function bo(t, e, l) {
+  var n, o;
+  let { node: i } = t, r = i.props.allowsSorting, { gridCellProps: d } = el({
+    ...t,
+    focusMode: "child"
+  }, e, l), s = i.props.isSelectionCell && e.selectionManager.selectionMode === "single", { pressProps: u, isPressed: f } = Zt({
+    isDisabled: !r || s,
+    onPress() {
+      e.sort(i.key);
+    },
+    ref: l
+  }), { focusableProps: a } = Gn({}, l), m, c = ((n = e.sortDescriptor) === null || n === void 0 ? void 0 : n.column) === i.key, p = (o = e.sortDescriptor) === null || o === void 0 ? void 0 : o.direction;
+  i.props.allowsSorting && !Mt() && (m = c ? p : "none");
+  let h = Me(ho(Ne), "@react-aria/table"), g;
+  r && (g = `${h.format("sortable")}`, c && p && Mt() && (g = `${g}, ${h.format(p)}`));
+  let b = ct(g), y = e.collection.size === 0;
+  return fe(() => {
+    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: tl(e, i.key),
+      "aria-colspan": i.colSpan && i.colSpan > 1 ? i.colSpan : void 0,
+      "aria-sort": m
+    },
+    isPressed: f
+  };
+}
+const Ft = {
+  expand: {
+    ltr: "ArrowRight",
+    rtl: "ArrowLeft"
+  },
+  collapse: {
+    ltr: "ArrowLeft",
+    rtl: "ArrowRight"
+  }
+};
+function go(t, e, l) {
+  let { node: n, isVirtualized: o } = t, { rowProps: i, ...r } = co(t, e, l), { direction: d } = Ee();
+  o && !(Ye() && "expandedKeys" in e) ? i["aria-rowindex"] = n.index + 1 + e.collection.headerRows.length : delete i["aria-rowindex"];
+  let s = {};
+  if (Ye() && "expandedKeys" in e) {
+    let $ = e.keyMap.get(n.key);
+    if ($ != null) {
+      var u, f, a, m, c, p;
+      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 === Ft.expand[d] && e.selectionManager.focusedKey === $.key && S && e.expandedKeys !== "all" && !e.expandedKeys.has($.key) || E.key === Ft.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 = (m = ce((g = (c = e.keyMap.get($.parentKey)) === null || c === void 0 ? void 0 : c.childNodes) !== null && g !== void 0 ? g : [])) === null || m === void 0 ? void 0 : m.indexOfType) !== null && b !== void 0 ? b : 0) + 1 : ((y = (p = ce(e.collection.body.childNodes)) === null || p === void 0 ? void 0 : p.indexOfType) !== null && y !== void 0 ? y : 0) + 1
+      };
+    }
+  }
+  let v = Ln(n.props), C = r.hasAction ? v : {};
+  return {
+    rowProps: {
+      ...j(i, s, C),
+      "aria-labelledby": nl(e, n.key)
+    },
+    ...r
+  };
+}
+function vo(t, e, l) {
+  let { node: n, isVirtualized: o } = t, i = {
+    role: "row"
+  };
+  return o && !(Ye() && "expandedKeys" in e) && (i["aria-rowindex"] = n.index + 1), {
+    rowProps: i
+  };
+}
+function yo(t, e, l) {
+  var n;
+  let { gridCellProps: o, isPressed: i } = el(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 = ll(e, t.node.parentKey, r)), {
+    gridCellProps: o,
+    isPressed: i
+  };
+}
+function $o(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function xo(t, e) {
+  let { key: l } = t;
+  const { checkboxProps: n } = $n(t, e);
+  return {
+    checkboxProps: {
+      ...n,
+      "aria-labelledby": `${n.id} ${nl(e, l)}`
+    }
+  };
+}
+function Co(t) {
+  let { isEmpty: e, isSelectAll: l, selectionMode: n } = t.selectionManager;
+  return {
+    checkboxProps: {
+      "aria-label": Me($o(Ne), "@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 wo(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function Do(t, e, l) {
+  let { column: n, triggerRef: o, isDisabled: i, onResizeStart: r, onResize: d, onResizeEnd: s, "aria-label": u } = t;
+  const f = Me(wo(Ne), "@react-aria/table");
+  let a = dt(), m = e.resizingColumn === n.key, c = P(m), p = P(null), h = P(!1), g = e.tableState.isKeyboardNavigationDisabled, { direction: b } = Ee(), y = M((w) => {
+    c.current || (p.current = e.updateResizedColumns(w.key, e.getColumnWidth(w.key)), e.startResize(w.key), e.tableState.setKeyboardNavigationDisabled(!0), r?.(p.current)), c.current = !0;
+  }, [
+    e,
+    r
+  ]), v = M((w, T) => {
+    let G = e.updateResizedColumns(w.key, T);
+    d?.(G), p.current = G;
+  }, [
+    e,
+    d
+  ]), C = M((w) => {
+    c.current && (p.current == null && (p.current = e.updateResizedColumns(w.key, e.getColumnWidth(w.key))), e.endResize(), e.tableState.setKeyboardNavigationDisabled(!1), s?.(p.current), c.current = !1, o?.current && !h.current && _(o.current)), p.current = null;
+  }, [
+    e,
+    o,
+    s
+  ]), { keyboardProps: $ } = Yn({
+    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 } = ro({
+    onMoveStart() {
+      S.current = e.getColumnWidth(n.key), y(n);
+    },
+    onMove(w) {
+      let { deltaX: T, deltaY: G, pointerType: et } = w;
+      b === "rtl" && (T *= -1), et === "keyboard" && (G !== 0 && T === 0 && (T = G * -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 H = Math.floor(e.getColumnWidth(n.key)), L = qn();
+  L === "virtual" && typeof window < "u" && "ontouchstart" in window && (L = "touch");
+  let U = o?.current == null && (L === "keyboard" || L === "virtual") && !m ? f.format("resizerDescription") : void 0, N = ct(U), F = {
+    "aria-label": u,
+    "aria-orientation": "horizontal",
+    "aria-labelledby": `${a} ${tl(e.tableState, n.key)}`,
+    "aria-valuetext": f.format("columnSize", {
+      value: H
+    }),
+    type: "range",
+    min: R,
+    max: k,
+    value: H,
+    ...N
+  };
+  const X = M(() => {
+    l.current && _(l.current);
+  }, [
+    l
+  ]);
+  let O = e.resizingColumn, te = P(null), be = it(y);
+  fe(() => {
+    if (te.current !== O && O != null && O === n.key) {
+      h.current = document.activeElement === l.current, be(n);
+      let w = setTimeout(() => X(), 0), T = setTimeout(X, 400);
+      return () => {
+        clearTimeout(w), clearTimeout(T);
+      };
+    }
+    te.current = O;
+  }, [
+    O,
+    n,
+    X,
+    l
+  ]);
+  let le = (w) => {
+    let T = e.getColumnWidth(n.key), G = parseFloat(w.target.value);
+    G > T ? G = T + 10 : G = T - 10, v(n, G);
+  }, { pressProps: ne } = Zt({
+    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: ue } = Je();
+  return {
+    resizerProps: j($, {
+      ...E,
+      onKeyDown: B
+    }, ne, {
+      style: {
+        touchAction: "none"
+      }
+    }),
+    inputProps: j(ue, {
+      id: a,
+      onBlur: () => {
+        C(n);
+      },
+      onChange: le,
+      disabled: i
+    }, F),
+    isResizing: m
+  };
+}
+function Il() {
+  return uo();
+}
+function So(t) {
+  return t != null && (!isNaN(t) || String(t).match(/^(\d+)(?=%$)/) !== null);
+}
+function Eo(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 mt(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 Vl(t, e) {
+  return t != null ? mt(t, e) : Number.MAX_SAFE_INTEGER;
+}
+function Hl(t, e) {
+  return t != null ? mt(t, e) : 0;
+}
+function ko(t, e, l, n, o) {
+  let i = !1, r = e.map((d, s) => {
+    var u, f, a, m;
+    let c = l.get(d.key) != null ? (u = l.get(d.key)) !== null && u !== void 0 ? u : "1fr" : (m = (a = (f = d.width) !== null && f !== void 0 ? f : d.defaultWidth) !== null && a !== void 0 ? a : n?.(s)) !== null && m !== void 0 ? m : "1fr", p = !1, h = 0, g = 0, b = 0;
+    So(c) ? (h = mt(c, t), p = !0) : (g = Eo(c), g <= 0 && (p = !0));
+    var y, v;
+    let C = Hl((v = (y = d.minWidth) !== null && y !== void 0 ? y : o?.(s)) !== null && v !== void 0 ? v : 0, t), $ = Vl(d.maxWidth, t), S = Math.max(C, Math.min(h, $));
+    return p ? b = S : h > S && (p = !0, b = S), p || (i = !0), {
+      frozen: p,
+      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 m = a.flex / s;
+        a.targetMainSize = a.baseSize + m * u;
+      }
+    });
+    let f = 0;
+    r.forEach((a) => {
+      if (a.violation = 0, !a.frozen) {
+        let { min: m, max: c, targetMainSize: p } = a;
+        a.targetMainSize = Math.max(m, Math.min(p, c)), a.violation = a.targetMainSize - p, 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 zo(r);
+}
+function zo(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 Ro {
+  /** 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(), ko(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, Hl((u = s.props.minWidth) !== null && u !== void 0 ? u : this.getDefaultMinWidth(s), e)), this.columnMaxWidths.set(d, Vl(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 Ao(t, e) {
+  let { getDefaultWidth: l, getDefaultMinWidth: n, tableWidth: o = 0 } = t, [i, r] = Z(null), d = K(() => new Ro({
+    getDefaultWidth: l,
+    getDefaultMinWidth: n
+  }), [
+    l,
+    n
+  ]), [s, u] = K(() => d.splitColumnsIntoControlledAndUncontrolled(e.collection.columns), [
+    e.collection.columns,
+    d
+  ]), [f, a] = Z(() => d.getInitialUncontrolledWidths(u)), [m, c] = Z(e.collection.columns);
+  if (e.collection.columns !== m) {
+    if (e.collection.columns.length !== m.length || e.collection.columns.some((v, C) => v.key !== m[C].key)) {
+      let v = d.getInitialUncontrolledWidths(u);
+      a(v);
+    }
+    c(e.collection.columns);
+  }
+  let p = 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, p), [
+    o,
+    e.collection,
+    p,
+    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 To(t) {
+  let { collection: e, focusMode: l } = t, n = t.UNSAFE_selectionState || Yt(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 p = e.getItem(s);
+      if (p?.type === "item") {
+        var f, a;
+        let h = W(p, e);
+        var m, c;
+        u === "last" ? s = (m = (f = ce(h)) === null || f === void 0 ? void 0 : f.key) !== null && m !== void 0 ? m : null : s = (c = (a = de(h)) === null || a === void 0 ? void 0 : a.key) !== null && c !== void 0 ? c : null;
+      }
+    }
+    i(s, u);
+  };
+  let r = K(() => new Sn(e, n), [
+    e,
+    n
+  ]);
+  const d = P(null);
+  return fe(() => {
+    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, m = f.length - a.length;
+      let c = Math.min(m > 1 ? Math.max(u.index - m + 1, 0) : u.index, a.length - 1), p = null;
+      for (; c >= 0; ) {
+        if (!r.isDisabled(a[c].key) && a[c].type !== "headerrow") {
+          p = a[c];
+          break;
+        }
+        c < a.length - 1 ? c++ : (c > u.index && (c = u.index), c--);
+      }
+      if (p) {
+        const h = p.hasChildNodes ? [
+          ...W(p, e)
+        ] : [], g = p.hasChildNodes && u !== s && s && s.index < h.length ? h[s.index].key : p.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 Po {
+  *[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 m = this.keyMap.get(a.key);
+      e.visitNode && (a = e.visitNode(a)), this.keyMap.set(a.key, a);
+      let c = /* @__PURE__ */ new Set(), p = 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 = p ? ((v = p.colIndex) !== null && v !== void 0 ? v : p.index) + ((C = p.colSpan) !== null && C !== void 0 ? C : 1) : $.index;
+        }
+        $.type === "cell" && $.parentKey == null && ($.parentKey = a.key), c.add($.key), p ? (p.nextKey = $.key, $.prevKey = p.key) : $.prevKey = null, l($), p = $;
+      }
+      if (p && (p.nextKey = null), m)
+        for (let $ of m.childNodes) c.has($.key) || n($);
+    }, n = (a) => {
+      this.keyMap.delete(a.key);
+      for (let m of a.childNodes) this.keyMap.get(m.key) === m && n(m);
+    }, o = null;
+    for (let [a, m] of e.items.entries()) {
+      var i, r, d, s, u, f;
+      let c = {
+        ...m,
+        level: (i = m.level) !== null && i !== void 0 ? i : 0,
+        key: (r = m.key) !== null && r !== void 0 ? r : "row-" + a,
+        type: (d = m.type) !== null && d !== void 0 ? d : "row",
+        value: (s = m.value) !== null && s !== void 0 ? s : null,
+        hasChildNodes: !0,
+        childNodes: [
+          ...m.childNodes
+        ],
+        rendered: m.rendered,
+        textValue: (u = m.textValue) !== null && u !== void 0 ? u : "",
+        index: (f = m.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 Wl = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+let at = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+for (; Wl === at; ) at = "row-header-column-" + Math.random().toString(36).slice(2);
+function Ll(t, e) {
+  if (e.length === 0) return [];
+  let l = [], n = /* @__PURE__ */ new Map();
+  for (let f of e) {
+    let a = f.parentKey, m = [
+      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: p, index: h } = n.get(c);
+        if (h > m.length) break;
+        for (let g = h; g < m.length; g++) p.splice(g, 0, null);
+        for (let g = m.length; g < p.length; g++)
+          p[g] && n.has(p[g]) && (n.get(p[g]).index = g);
+      } else
+        c.colSpan = 1, c.colspan = 1, m.push(c), n.set(c, {
+          column: m,
+          index: m.length - 1
+        });
+      a = c.parentKey;
+    }
+    l.push(m), 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 m of f) {
+      if (m) {
+        let c = d[a], p = c.reduce((h, g) => {
+          var b;
+          return h + ((b = g.colSpan) !== null && b !== void 0 ? b : 1);
+        }, 0);
+        if (p < s) {
+          let h = {
+            type: "placeholder",
+            key: "placeholder-" + m.key,
+            colspan: s - p,
+            colSpan: s - p,
+            index: p,
+            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 = m.key, m.prevKey = c[c.length - 1].key), m.level = a, m.colIndex = s, c.push(m);
+      }
+      a--;
+    }
+    s++;
+  }
+  let u = 0;
+  for (let f of d) {
+    let a = f.reduce((m, c) => {
+      var p;
+      return m + ((p = c.colSpan) !== null && p !== void 0 ? p : 1);
+    }, 0);
+    if (a < e.length) {
+      let m = {
+        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(m);
+    }
+    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 Bo extends Po {
+  *[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 = de(this.body.childNodes)) === null || e === void 0 ? void 0 : e.key) !== null && l !== void 0 ? l : null;
+  }
+  getLastKey() {
+    var e, l;
+    return (l = (e = ce(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: Wl,
+        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: at,
+        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 m of a.childNodes) u(m);
+    };
+    for (let a of e) u(a);
+    let f = Ll(s, r);
+    if (f.forEach((a, m) => d.splice(m, 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((m) => {
+        var c, p;
+        return !(!((c = m.props) === null || c === void 0) && c.isDragButtonCell) && !(!((p = m.props) === null || p === void 0) && p.isSelectionCell);
+      });
+      a && this.rowHeaderColumnKeys.add(a.key);
+    }
+  }
+}
+const Ko = {
+  ascending: "descending",
+  descending: "ascending"
+};
+function Mo(t) {
+  let [e, l] = Z(!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 = En(t, M((a) => new Bo(a, null, r), [
+    r
+  ]), r), { disabledKeys: s, selectionManager: u } = To({
+    ...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, m) {
+      var c, p;
+      (p = t.onSortChange) === null || p === void 0 || p.call(t, {
+        column: a,
+        direction: m ?? (((c = t.sortDescriptor) === null || c === void 0 ? void 0 : c.column) === a ? Ko[t.sortDescriptor.direction] : "ascending")
+      });
+    }
+  };
+}
+function No(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 Fo(t) {
+  return t && t.__esModule ? t.default : t;
+}
+class Io extends Nn {
+  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 = Ll(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 gt(-1), this.body = new vt(-2), this.columnsDirty = !0;
+  }
+}
+const ht = /* @__PURE__ */ pe(null), Vo = /* @__PURE__ */ J(function(e, l) {
+  let n = Q(l), o = P(null), i = P(null), [r, d] = Z(0);
+  ot(() => {
+    let u = o.current;
+    for (; u && u !== n.current && !Hn(u); ) u = u.parentElement;
+    i.current = u;
+  }, [
+    n
+  ]), Vn({
+    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);
+    }
+  }), ot(() => {
+    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: Ao,
+    onResizeStart: e.onResizeStart,
+    onResize: e.onResize,
+    onResizeEnd: e.onResizeEnd
+  }), [
+    o,
+    r,
+    e.onResizeStart,
+    e.onResize,
+    e.onResizeEnd
+  ]);
+  return /* @__PURE__ */ D.createElement(I.div, {
+    render: e.render,
+    ...ee(e, {
+      global: !0
+    }),
+    ref: n,
+    className: e.className || "react-aria-ResizableTableContainer",
+    style: e.style,
+    onScroll: e.onScroll
+  }, /* @__PURE__ */ D.createElement(ht.Provider, {
+    value: s
+  }, e.children));
+}), Ho = /* @__PURE__ */ pe(null), re = /* @__PURE__ */ pe(null), bt = /* @__PURE__ */ pe(null), Wo = /* @__PURE__ */ J(function(e, l) {
+  var n;
+  [e, l] = Ut(e, l, Ho);
+  let o = Yt(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(Ol.Provider, {
+    value: u
+  }, /* @__PURE__ */ D.createElement(Be, e));
+  return /* @__PURE__ */ D.createElement(Kn, {
+    content: f,
+    createCollection: () => new Io()
+  }, (a) => /* @__PURE__ */ D.createElement(Oo, {
+    props: e,
+    forwardedRef: l,
+    selectionState: o,
+    collection: a
+  }));
+});
+let Lo = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.table, {
+    ...e,
+    ref: l
+  });
+});
+function Oo({ props: t, forwardedRef: e, selectionState: l, collection: n }) {
+  [t, e] = Ut(t, e, Pt);
+  let { shouldUseVirtualFocus: o, disallowTypeAhead: i, filter: r, ...d } = t, s = z(ht);
+  e = Q(K(() => In(e, s?.tableRef), [
+    e,
+    s?.tableRef
+  ]));
+  let u = Mo({
+    ...d,
+    collection: n,
+    children: void 0,
+    UNSAFE_selectionState: l
+  }), f = No(u, r), { isVirtualized: a, layoutDelegate: m, dropTargetDelegate: c, CollectionRoot: p } = z(V), { dragAndDropHooks: h } = t, { gridProps: g } = mo({
+    ...d,
+    layoutDelegate: m,
+    isVirtualized: a
+  }, f, e), b = f.selectionManager, y = !!h?.useDraggableCollectionState, v = !!h?.useDroppableCollectionState, C = P(y), $ = P(v);
+  fe(() => {
+    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, H = P(null);
+  if (y && h) {
+    S = h.useDraggableCollectionState({
+      collection: f.collection,
+      selectionManager: b,
+      preview: h.renderDragPreview ? H : void 0
+    }), h.useDraggableCollection({}, S, e);
+    let ne = h.DragPreview;
+    k = h.renderDragPreview ? /* @__PURE__ */ D.createElement(ne, {
+      ref: H
+    }, h.renderDragPreview) : null;
+  }
+  if (v && h) {
+    E = h.useDroppableCollectionState({
+      collection: f.collection,
+      selectionManager: b
+    });
+    let ne = new Qn({
+      collection: f.collection,
+      disabledKeys: b.disabledKeys,
+      disabledBehavior: b.disabledBehavior,
+      ref: e,
+      layoutDelegate: m
+    }), ue = h.dropTargetDelegate || c || new h.ListDropTargetDelegate(n.rows, e);
+    B = h.useDroppableCollection({
+      keyboardDelegate: ne,
+      dropTargetDelegate: ue
+    }, E, e), R = E.isDropTarget({
+      type: "root"
+    });
+  }
+  let { focusProps: L, isFocused: U, isFocusVisible: N } = De(), F = me({
+    ...t,
+    children: void 0,
+    defaultClassName: "react-aria-Table",
+    values: {
+      isDropTarget: R,
+      isFocused: U,
+      isFocusVisible: N,
+      state: f
+    }
+  }), X = !!(y && !S?.isDisabled), O = F.style, te = null;
+  s && (te = s.useTableColumnResizeState({
+    tableWidth: s.tableWidth
+  }, f), a || (O = {
+    ...O,
+    tableLayout: "fixed",
+    width: "fit-content"
+  }));
+  let be = ee(t, {
+    global: !0
+  });
+  var le;
+  return /* @__PURE__ */ D.createElement(qe, {
+    values: [
+      [
+        re,
+        f
+      ],
+      [
+        bt,
+        te
+      ],
+      [
+        Se,
+        {
+          dragAndDropHooks: h,
+          dragState: S,
+          dropState: E
+        }
+      ],
+      [
+        zn,
+        {
+          render: ei
+        }
+      ],
+      [
+        Pt,
+        null
+      ],
+      [
+        wn,
+        null
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(On, null, /* @__PURE__ */ D.createElement(Lo, {
+    ...j(be, F, g, L, B?.collectionProps),
+    style: O,
+    ref: e,
+    slot: t.slot || void 0,
+    onScroll: t.onScroll,
+    "data-allows-dragging": X || void 0,
+    "data-drop-target": R || void 0,
+    "data-focused": U || void 0,
+    "data-focus-visible": N || void 0
+  }, /* @__PURE__ */ D.createElement(Pn, null, /* @__PURE__ */ D.createElement(p, {
+    collection: f.collection,
+    scrollRef: (le = s?.scrollRef) !== null && le !== void 0 ? le : e,
+    persistedKeys: Rn(b, h, E)
+  })))), k);
+}
+const Ol = /* @__PURE__ */ pe(null);
+function jl() {
+  return z(Ol);
+}
+class gt extends Ze {
+}
+gt.type = "tableheader";
+let jo = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.thead, {
+    ...e,
+    ref: l
+  });
+});
+const Uo = /* @__PURE__ */ ut(gt, (t, e) => {
+  let l = z(re).collection, n = Bn({
+    items: l.headerRows,
+    children: M((s) => {
+      switch (s.type) {
+        case "headerrow":
+          return /* @__PURE__ */ D.createElement(Yo, {
+            item: s
+          });
+        default:
+          throw new Error("Unsupported node type in TableHeader: " + s.type);
+      }
+    }, [])
+  }), { rowGroupProps: o } = Il(), { hoverProps: i, isHovered: r } = Ke({
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), d = me({
+    ...t,
+    children: void 0,
+    defaultClassName: "react-aria-TableHeader",
+    values: {
+      isHovered: r
+    }
+  });
+  return /* @__PURE__ */ D.createElement(jo, {
+    ...j(ee(t, {
+      global: !0
+    }), o, i),
+    ...d,
+    ref: e,
+    "data-hovered": r || void 0
+  }, n);
+}, (t) => /* @__PURE__ */ D.createElement(Be, {
+  dependencies: t.dependencies,
+  items: t.columns
+}, t.children));
+let Go = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("tr", {
+    ...e,
+    ref: l
+  });
+});
+function Yo({ item: t }) {
+  let e = P(null), l = z(re), { isVirtualized: n, CollectionBranch: o } = z(V), { rowProps: i } = vo({
+    node: t,
+    isVirtualized: n
+  }, l, e), { checkboxProps: r } = Co(l);
+  return /* @__PURE__ */ D.createElement(Go, {
+    ...i,
+    ref: e
+  }, /* @__PURE__ */ D.createElement(qe, {
+    values: [
+      [
+        jt,
+        {
+          slots: {
+            selection: r
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(o, {
+    collection: l.collection,
+    parent: t
+  })));
+}
+class Ul extends Ze {
+}
+Ul.type = "column";
+let Xo = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.th, {
+    ...e,
+    ref: l
+  });
+});
+const qo = /* @__PURE__ */ qt(Ul, (t, e, l) => {
+  var n, o;
+  let i = Q(e), r = z(re), { isVirtualized: d } = z(V), { columnHeaderProps: s, isPressed: u } = bo({
+    node: l,
+    isVirtualized: d
+  }, r, i), { isFocused: f, isFocusVisible: a, focusProps: m } = De(), c = z(bt), p = !1;
+  if (c) p = 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 } = Ke({
+    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: p,
+      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 = ee(t, {
+    global: !0
+  });
+  return delete v.id, /* @__PURE__ */ D.createElement(Xo, {
+    ...j(v, s, m, 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": p || 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(qe, {
+    values: [
+      [
+        Gl,
+        {
+          column: l,
+          triggerRef: i
+        }
+      ],
+      [
+        V,
+        Xt
+      ]
+    ]
+  }, b.children));
+}), Gl = /* @__PURE__ */ pe(null), Zo = /* @__PURE__ */ J(function(e, l) {
+  let n = z(bt);
+  if (!n) throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+  let o = Me(Fo(An), "react-aria-components"), { onResizeStart: i, onResize: r, onResizeEnd: d } = z(ht), { column: s, triggerRef: u } = z(Gl), f = P(null), { resizerProps: a, inputProps: m, isResizing: c } = Do({
+    column: s,
+    "aria-label": e["aria-label"] || o.format("tableResizer"),
+    onResizeStart: i,
+    onResize: r,
+    onResizeEnd: d,
+    triggerRef: u
+  }, n, f), { focusProps: p, isFocused: h, isFocusVisible: g } = De(), { hoverProps: b, isHovered: y } = Ke(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] = Z("");
+  fe(() => {
+    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
+    }
+  }), [H, L] = Z(!1), U = (F) => {
+    F.pointerType === "mouse" && L(!0);
+  };
+  !c && H && L(!1);
+  let N = ee(e, {
+    global: !0
+  });
+  return /* @__PURE__ */ D.createElement(I.div, {
+    ref: E,
+    role: "presentation",
+    ...j(N, k, a, {
+      onPointerDown: U
+    }, 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(m, p)
+  }), c && H && /* @__PURE__ */ Wn.createPortal(/* @__PURE__ */ D.createElement("div", {
+    style: {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      bottom: 0,
+      right: 0,
+      cursor: B
+    }
+  }), document.body));
+});
+class vt extends Mn {
+}
+vt.type = "tablebody";
+let Jo = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.tbody, {
+    ...e,
+    ref: l
+  });
+});
+const Qo = /* @__PURE__ */ ut(vt, (t, e) => {
+  let l = z(re), { isVirtualized: n } = z(V), o = l.collection, { CollectionBranch: i } = z(V), { 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, m = {
+    isDropTarget: f,
+    isEmpty: a
+  }, c = me({
+    ...t,
+    id: void 0,
+    children: void 0,
+    defaultClassName: "react-aria-TableBody",
+    values: m
+  }), p, h = o.columnCount;
+  if (a && t.renderEmptyState && l) {
+    let y = {}, v = {}, C = {};
+    n ? (v["aria-colspan"] = h, C = {
+      display: "contents"
+    }) : v.colSpan = h, p = /* @__PURE__ */ D.createElement(Xe, {
+      role: "row",
+      ...y,
+      style: C
+    }, /* @__PURE__ */ D.createElement(Qe, {
+      role: "rowheader",
+      ...v,
+      style: C
+    }, t.renderEmptyState(m)));
+  }
+  let { rowGroupProps: g } = Il(), b = ee(t, {
+    global: !0
+  });
+  return /* @__PURE__ */ D.createElement(Jo, {
+    ...j(b, c, g),
+    ref: e,
+    "data-empty": a || void 0
+  }, s && /* @__PURE__ */ D.createElement(ii, null), /* @__PURE__ */ D.createElement(i, {
+    collection: o,
+    parent: o.body,
+    renderDropIndicator: kn(r, d)
+  }), p);
+});
+class Yl extends Ze {
+  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;
+  }
+}
+Yl.type = "item";
+let Xe = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.tr, {
+    ...e,
+    ref: l
+  });
+});
+const It = /* @__PURE__ */ ut(Yl, (t, e, l) => {
+  let n = Q(e), o = z(re), { dragAndDropHooks: i, dragState: r, dropState: d } = z(Se), { isVirtualized: s, CollectionBranch: u } = z(V), { rowProps: f, ...a } = go({
+    node: l,
+    shouldSelectOnPressUp: !!r,
+    isVirtualized: s
+  }, o, n), { isFocused: m, isFocusVisible: c, focusProps: p } = De(), { isFocusVisible: h, focusProps: g } = De({
+    within: !0
+  }), { hoverProps: b, isHovered: y } = Ke({
+    isDisabled: !a.allowsSelection && !a.hasAction,
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), { checkboxProps: v } = xo({
+    key: l.key
+  }, o), C;
+  r && i && (C = i.useDraggableItem({
+    key: l.key,
+    hasDragButton: !0
+  }, r));
+  let $, S = P(null), { visuallyHiddenProps: E } = Je();
+  d && i && ($ = i.useDropIndicator({
+    target: {
+      type: "item",
+      key: l.key,
+      dropPosition: "on"
+    }
+  }, d, S));
+  let B = P(null);
+  fe(() => {
+    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, ...H } = t, L = me({
+    ...H,
+    id: void 0,
+    defaultClassName: "react-aria-Row",
+    values: {
+      ...a,
+      isHovered: y,
+      isFocused: m,
+      isFocusVisible: c,
+      selectionMode: o.selectionManager.selectionMode,
+      selectionBehavior: o.selectionManager.selectionBehavior,
+      isDragging: R,
+      isDropTarget: $?.isDropTarget,
+      isFocusVisibleWithin: h,
+      id: l.key
+    }
+  }), U = ee(t, {
+    global: !0
+  });
+  return delete U.id, delete U.onClick, /* @__PURE__ */ D.createElement(D.Fragment, null, $ && !$.isHidden && /* @__PURE__ */ D.createElement(Xe, {
+    role: "row",
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ D.createElement(Qe, {
+    role: "gridcell",
+    colSpan: o.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    role: "button",
+    ...E,
+    ...$.dropIndicatorProps,
+    ref: S
+  }))), /* @__PURE__ */ D.createElement(Xe, {
+    ...j(U, L, f, p, 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(qe, {
+    values: [
+      [
+        jt,
+        {
+          slots: {
+            [Bt]: {},
+            selection: v
+          }
+        }
+      ],
+      [
+        Ot,
+        {
+          slots: {
+            [Bt]: {},
+            drag: {
+              ...C?.dragButtonProps,
+              ref: B,
+              style: {
+                pointerEvents: "none"
+              }
+            }
+          }
+        }
+      ],
+      [
+        Tn,
+        {
+          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(Be, {
+    dependencies: e,
+    items: t.columns,
+    idScope: t.id
+  }, t.children);
+});
+class Xl extends Ze {
+}
+Xl.type = "cell";
+let Qe = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.td, {
+    ...e,
+    ref: l
+  });
+});
+const _o = /* @__PURE__ */ qt(Xl, (t, e, l) => {
+  let n = Q(e), o = z(re), { dragState: i } = z(Se), { isVirtualized: r } = z(V);
+  l.column = o.collection.columns[l.index];
+  let { gridCellProps: d, isPressed: s } = yo({
+    node: l,
+    shouldSelectOnPressUp: !!i,
+    isVirtualized: r
+  }, o, n), { isFocused: u, isFocusVisible: f, focusProps: a } = De(), { hoverProps: m, isHovered: c } = Ke({}), p = l.parentKey != null ? o.selectionManager.isSelected(l.parentKey) : !1, h = l.colIndex || l.index, g = me({
+    ...t,
+    id: void 0,
+    defaultClassName: "react-aria-Cell",
+    values: {
+      isFocused: u,
+      isFocusVisible: f,
+      isPressed: s,
+      isHovered: c,
+      isSelected: p,
+      id: l.key,
+      columnIndex: h
+    }
+  }), b = ee(t, {
+    global: !0
+  });
+  return delete b.id, /* @__PURE__ */ D.createElement(Qe, {
+    ...j(b, g, d, a, m),
+    ref: n,
+    "data-focused": u || void 0,
+    "data-focus-visible": f || void 0,
+    "data-pressed": s || void 0,
+    "data-selected": p || void 0,
+    "data-column-index": h
+  }, /* @__PURE__ */ D.createElement(V.Provider, {
+    value: Xt
+  }, g.children));
+});
+function ei(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(oi, {
+    ...t,
+    dropIndicatorProps: i,
+    isDropTarget: d,
+    buttonRef: o,
+    ref: e
+  });
+}
+let ti = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.tr, {
+    ...e,
+    ref: l
+  });
+}), li = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = z(V);
+  return n ? /* @__PURE__ */ D.createElement(I.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(I.td, {
+    ...e,
+    ref: l
+  });
+});
+function ni(t, e) {
+  let { dropIndicatorProps: l, isDropTarget: n, buttonRef: o, ...i } = t, r = z(re), { visuallyHiddenProps: d } = Je(), s = me({
+    ...i,
+    defaultClassName: "react-aria-DropIndicator",
+    values: {
+      isDropTarget: n
+    }
+  });
+  return /* @__PURE__ */ D.createElement(ti, {
+    ...ee(t, {
+      global: !0
+    }),
+    ...s,
+    role: "row",
+    ref: e,
+    "data-drop-target": n || void 0
+  }, /* @__PURE__ */ D.createElement(li, {
+    role: "gridcell",
+    colSpan: r.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    ...d,
+    role: "button",
+    ...l,
+    ref: o
+  }), s.children));
+}
+const oi = /* @__PURE__ */ J(ni);
+function ii() {
+  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 } = Je();
+  return !i && o["aria-hidden"] ? null : /* @__PURE__ */ D.createElement(Xe, {
+    role: "row",
+    "aria-hidden": o["aria-hidden"],
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ D.createElement(Qe, {
+    role: "gridcell",
+    colSpan: t.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    role: "button",
+    ...r,
+    ...o,
+    ref: n
+  })));
+}
+const { withProvider: ri, withContext: ae } = /* @__PURE__ */ nn({
+  key: "nimbusDataTable"
+}), ai = /* @__PURE__ */ ri("div", "root"), si = /* @__PURE__ */ ae("table", "table"), ui = /* @__PURE__ */ ae("tr", "header"), di = /* @__PURE__ */ ae("th", "column"), ci = /* @__PURE__ */ ae("tbody", "body"), Vt = /* @__PURE__ */ ae("tr", "row"), fi = /* @__PURE__ */ ae("td", "cell"), pi = /* @__PURE__ */ ae("footer", "footer"), mi = /* @__PURE__ */ ae("span", "headerSortIcon"), hi = /* @__PURE__ */ ae("div", "columnResizer"), _e = /* @__PURE__ */ pe(null);
+_e.displayName = "DataTable.Context";
+const yt = /* @__PURE__ */ pe(null);
+yt.displayName = "CustomSettings.Context";
+const he = () => {
+  const t = z(
+    _e
+  );
+  if (!t)
+    throw new Error("DataTable components must be used within DataTable.Root");
+  return t;
+}, bi = () => {
+  const t = z(yt);
+  if (!t)
+    throw new Error(
+      "CustomSettings components must be used within CustomSettings.Root"
+    );
+  return t;
+};
+function ql(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 = ql(
+          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 Zl(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 m = u.accessor(f), c = u.accessor(a);
+      if (m == null && c == null) return 0;
+      if (m == null) return 1;
+      if (c == null) return -1;
+      const p = typeof m == "number" && typeof c == "number" ? m : String(m).toLowerCase(), h = typeof m == "number" && typeof c == "number" ? c : String(c).toLowerCase();
+      return p < h ? e.direction === "ascending" ? -1 : 1 : p > h ? e.direction === "ascending" ? 1 : -1 : 0;
+    }));
+  }
+  return [...i, ...d].map((u) => !n || !u[n] ? u : {
+    ...u,
+    [n]: Array.isArray(u[n]) ? Zl(
+      u[n],
+      e,
+      l,
+      n,
+      o
+    ) : u[n]
+  });
+}
+function Jl(t, e) {
+  return e ? t.some(
+    (l) => l[e] && (Array.isArray(l[e]) ? l[e].length > 0 : !0) || Array.isArray(l[e]) && Jl(l[e], e)
+  ) : !1;
+}
+const $t = function(e) {
+  const {
+    ref: l,
+    columns: n = [],
+    rows: o = [],
+    visibleColumns: i,
+    search: r,
+    sortDescriptor: d,
+    defaultSortDescriptor: s,
+    onSortChange: u,
+    selectedKeys: f,
+    defaultSelectedKeys: a,
+    onSelectionChange: m,
+    selectionMode: c = "none",
+    disallowEmptySelection: p = !1,
+    allowsSorting: h = !1,
+    maxHeight: g,
+    isTruncated: b = !1,
+    density: y = "default",
+    nestedKey: v,
+    onRowClick: C,
+    onDetailsClick: $,
+    disabledKeys: S,
+    onRowAction: E,
+    isResizable: B,
+    expandedRows: R,
+    defaultExpandedRows: k,
+    onExpandRowsChange: H,
+    pinnedRows: L,
+    defaultPinnedRows: U,
+    onPinToggle: N,
+    onColumnsChange: F,
+    onSettingsChange: X,
+    customSettings: O,
+    children: te,
+    ...be
+  } = e, le = P(null), ne = Q(Pe(le, l)), [ue, w] = Z(s), [T, G] = Z(
+    () => k || /* @__PURE__ */ new Set()
+  ), [et, en] = Z(
+    () => U || /* @__PURE__ */ new Set()
+  ), Fe = d ?? ue, Ie = R ?? T, Ve = L ?? et, ge = K(() => {
+    if (!i)
+      return n;
+    const q = new Map(n.map((Y) => [Y.id, Y]));
+    return i.map((Y) => q.get(Y)).filter((Y) => Y !== void 0);
+  }, [n, i]), He = K(
+    () => r ? ql(o, r, ge, v) : o,
+    [o, r, ge, v]
+  ), tt = K(
+    () => Zl(
+      He,
+      Fe,
+      ge,
+      v,
+      Ve
+    ),
+    [He, Fe, ge, v, Ve]
+  ), St = Jl(tt, v), Et = c !== "none", kt = M(
+    (q) => {
+      const Y = new Set(Ie);
+      Y.has(q) ? Y.delete(q) : Y.add(q), H?.(Y), R === void 0 && G(Y);
+    },
+    [Ie, H, R]
+  ), zt = M(
+    (q) => {
+      N ? N(q) : en((Y) => {
+        const We = new Set(Y);
+        return We.has(q) ? We.delete(q) : We.add(q), We;
+      });
+    },
+    [N]
+  ), Rt = M(
+    (q) => {
+      u ? u(q) : w(q);
+    },
+    [u]
+  ), tn = K(
+    () => ({
+      columns: n,
+      rows: o,
+      visibleColumns: i,
+      search: r,
+      sortDescriptor: Fe,
+      selectedKeys: f,
+      defaultSelectedKeys: a,
+      expanded: Ie,
+      allowsSorting: h,
+      selectionMode: c,
+      disallowEmptySelection: p,
+      maxHeight: g,
+      isTruncated: b,
+      density: y,
+      nestedKey: v,
+      onSortChange: Rt,
+      onSelectionChange: m,
+      onRowClick: C,
+      onDetailsClick: $,
+      toggleExpand: kt,
+      activeColumns: ge,
+      filteredRows: He,
+      sortedRows: tt,
+      showExpandColumn: St,
+      showSelectionColumn: Et,
+      isResizable: B,
+      disabledKeys: S,
+      onRowAction: E,
+      pinnedRows: Ve,
+      onPinToggle: N,
+      togglePin: zt,
+      onColumnsChange: F,
+      onSettingsChange: X
+    }),
+    [
+      n,
+      o,
+      i,
+      r,
+      Fe,
+      f,
+      a,
+      Ie,
+      h,
+      c,
+      p,
+      g,
+      b,
+      y,
+      v,
+      Rt,
+      m,
+      C,
+      $,
+      kt,
+      ge,
+      He,
+      tt,
+      St,
+      Et,
+      B,
+      S,
+      E,
+      Ve,
+      N,
+      zt,
+      F,
+      X
+    ]
+  ), ln = K(
+    () => ({
+      customSettings: O
+    }),
+    [O]
+  );
+  return /* @__PURE__ */ x(
+    ai,
+    {
+      ref: ne,
+      truncated: b,
+      density: y,
+      maxH: g,
+      ...be,
+      asChild: !0,
+      children: /* @__PURE__ */ x(Vo, { children: /* @__PURE__ */ x(
+        _e.Provider,
+        {
+          value: tn,
+          children: /* @__PURE__ */ x(yt.Provider, { value: ln, children: te })
+        }
+      ) })
+    }
+  );
+};
+$t.displayName = "DataTable.Root";
+const gi = {
+  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"
+}, vi = {
+  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"
+}, yi = {
+  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"
+}, $i = {
+  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"
+}, xi = {
+  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"
+}, se = {
+  en: /* @__PURE__ */ ze(gi),
+  de: /* @__PURE__ */ ze(vi),
+  es: /* @__PURE__ */ ze(yi),
+  "fr-FR": /* @__PURE__ */ ze($i),
+  "pt-BR": /* @__PURE__ */ ze(xi)
+}, xt = function({
+  ref: e,
+  children: l,
+  "aria-label": n,
+  ...o
+}) {
+  const i = P(null), r = Q(Pe(i, e)), d = ie(se), {
+    sortDescriptor: s,
+    onSortChange: u,
+    selectionMode: f,
+    onSelectionChange: a,
+    selectedKeys: m,
+    defaultSelectedKeys: c,
+    disallowEmptySelection: p,
+    disabledKeys: h
+  } = he(), [g, b] = ke(o), y = n ?? d.format("dataTable"), v = s ? {
+    column: s.column,
+    direction: s.direction
+  } : void 0;
+  return /* @__PURE__ */ x(si, { ...g, asChild: !0, children: /* @__PURE__ */ x(
+    Wo,
+    {
+      ref: r,
+      "aria-label": y,
+      sortDescriptor: v,
+      onSortChange: ($) => {
+        $ && u && u({
+          column: String($.column),
+          direction: $.direction
+        });
+      },
+      selectedKeys: m,
+      defaultSelectedKeys: c,
+      onSelectionChange: a,
+      selectionMode: f,
+      disallowEmptySelection: p,
+      disabledKeys: h,
+      disabledBehavior: "all",
+      ...b,
+      children: l
+    }
+  ) });
+};
+xt.displayName = "DataTable.Table";
+const Ae = ({
+  children: t,
+  ref: e,
+  column: l,
+  isInternalColumn: n,
+  width: o,
+  minWidth: i,
+  maxWidth: r,
+  ...d
+}) => {
+  const s = ie(se), { sortDescriptor: u, isResizable: f } = he(), a = u?.column === l?.id, m = l?.isResizable !== void 0 ? l?.isResizable : f, [c, p] = ke(d);
+  return /* @__PURE__ */ x(di, { ...c, asChild: !0, children: /* @__PURE__ */ x(
+    qo,
+    {
+      width: o,
+      minWidth: i,
+      maxWidth: r,
+      ref: e,
+      ...p,
+      children: (h) => {
+        const { allowsSorting: g } = h;
+        return n ? typeof t == "function" ? t(h) : t : /* @__PURE__ */ A(
+          io,
+          {
+            tabIndex: m || g ? -1 : 0,
+            className: "nimbus-data-table__column-container",
+            children: [
+              /* @__PURE__ */ x(
+                Lt,
+                {
+                  orientation: "vertical",
+                  className: "data-table-column-divider"
+                }
+              ),
+              typeof t == "function" ? t(h) : t,
+              g && /* @__PURE__ */ x(
+                mi,
+                {
+                  "aria-hidden": "true",
+                  "data-sort-active": a,
+                  "data-sort-direction": a ? u?.direction : "none",
+                  children: /* @__PURE__ */ x(on, {})
+                }
+              ),
+              m && /* @__PURE__ */ x(Zo, { "aria-label": s.format("resizeColumn"), children: ({ isResizing: b, isFocused: y, isHovered: v }) => /* @__PURE__ */ x(
+                hi,
+                {
+                  "data-resizing": b,
+                  "data-focused": y,
+                  "data-hovered": v
+                }
+              ) })
+            ]
+          }
+        );
+      }
+    }
+  ) });
+};
+Ae.displayName = "DataTable.Column";
+const Ct = ({
+  ref: t,
+  "aria-label": e,
+  ...l
+}) => {
+  const n = ie(se), { activeColumns: o, allowsSorting: i, maxHeight: r, showExpandColumn: d } = he(), { selectionBehavior: s, selectionMode: u } = jl(), [f, a] = ke(l), m = e ?? n.format("dataTableHeader");
+  return /* @__PURE__ */ x(ui, { ...f, asChild: !0, children: /* @__PURE__ */ A(
+    Uo,
+    {
+      ref: t,
+      "aria-label": m,
+      className: "data-table-header",
+      ...r && { "data-sticky": !0 },
+      columns: o,
+      ...a,
+      children: [
+        s === "toggle" && /* @__PURE__ */ x(
+          Ae,
+          {
+            id: "selection",
+            className: "selection-column-header",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            children: u === "multiple" && /* @__PURE__ */ x(Qt, { slot: "selection" })
+          }
+        ),
+        d && /* @__PURE__ */ x(
+          Ae,
+          {
+            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(Kt, { children: n.format("expandRows") })
+          }
+        ),
+        /* @__PURE__ */ x(Be, { items: o, children: (c) => /* @__PURE__ */ A(
+          Ae,
+          {
+            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(
+          Ae,
+          {
+            className: "pin-rows-column-header",
+            id: "pin-rows",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            "aria-label": n.format("pinRows"),
+            children: /* @__PURE__ */ x(Kt, { children: n.format("pinRows") })
+          }
+        )
+      ]
+    }
+  ) });
+};
+Ct.displayName = "DataTable.Header";
+const Ce = ({
+  ref: t,
+  children: e,
+  isDisabled: l,
+  ...n
+}) => {
+  const [o, i] = ke(n);
+  return /* @__PURE__ */ x(fi, { asChild: !0, ...o, children: /* @__PURE__ */ x(_o, { ref: t, ...i, children: (r) => /* @__PURE__ */ x(Ot.Provider, { value: { isDisabled: l }, children: typeof e == "function" ? e(r) : e }) }) });
+};
+Ce.displayName = "DataTable.Cell";
+function st(t) {
+  return t.target?.closest(
+    'button, input, [role="button"], [role="checkbox"], [slot="selection"], [data-slot="selection"]'
+  );
+}
+function Ht(t) {
+  st(t) || t.stopPropagation();
+}
+const Ql = ({
+  row: t,
+  ref: e,
+  ...l
+}) => {
+  const n = ie(se), {
+    activeColumns: o,
+    search: i,
+    expanded: r,
+    toggleExpand: d,
+    nestedKey: s,
+    disabledKeys: u,
+    showExpandColumn: f,
+    showSelectionColumn: a,
+    isTruncated: m,
+    onRowClick: c,
+    onRowAction: p,
+    pinnedRows: h,
+    togglePin: g,
+    sortedRows: b
+  } = he(), [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 = st(w), G = window.getSelection()?.toString() !== void 0 && window.getSelection().toString().length > 0;
+      !T && !G && (S.current && window.clearTimeout(S.current), S.current = window.setTimeout(() => {
+        $ ? p && p(t, "click") : c(t), S.current = null;
+      }, 300));
+    },
+    [c, p, t, $]
+  ), B = M((w) => {
+    st(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",
+        Ht,
+        {
+          capture: !0
+        }
+      ), w.addEventListener("mouseup", E, { capture: !0 }), w.addEventListener("dblclick", B, {
+        capture: !0
+      }));
+    },
+    [E, B]
+  );
+  fe(() => () => {
+    S.current && (window.clearTimeout(S.current), S.current = null), R.current.count >= 1 && R.current.node && (R.current.node.removeEventListener(
+      "pointerdown",
+      Ht
+    ), R.current.node.removeEventListener("mouseup", E), R.current.node.removeEventListener(
+      "dblclick",
+      B
+    ));
+  }, [E, B]);
+  const H = Pe(e, k), { selectionBehavior: L } = jl(), U = s && t[s] && (Array.isArray(t[s]) ? t[s].length > 0 : !0), N = r.has(t.id), F = h.has(t.id), X = b.filter((w) => h.has(w.id)).map((w) => w.id), O = F ? X.indexOf(t.id) : -1, te = O === 0, be = O === X.length - 1, le = X.length === 1 && F, ne = () => F ? le ? "data-table-row-pinned-single" : te ? "data-table-row-pinned-first" : be ? "data-table-row-pinned-last" : "" : "", ue = (w) => i && typeof w == "string" ? /* @__PURE__ */ x(oo, { query: i, ignoreCase: !0, matchAll: !0, children: w }) : w;
+  return /* @__PURE__ */ A(Re, { children: [
+    /* @__PURE__ */ x(Vt, { asChild: !0, ...y, children: /* @__PURE__ */ A(
+      It,
+      {
+        isDisabled: $,
+        columns: o,
+        ref: H,
+        id: t.id,
+        className: `data-table-row ${$ ? "data-table-row-disabled" : ""} ${F ? `data-table-row-pinned ${ne()}` : ""}`,
+        ...v,
+        dependencies: [N, i, m],
+        children: [
+          L === "toggle" && /* @__PURE__ */ x(
+            Ce,
+            {
+              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(
+                    Qt,
+                    {
+                      name: "select-row",
+                      slot: "selection",
+                      "aria-label": n.format("selectRow")
+                    }
+                  )
+                }
+              )
+            }
+          ),
+          f && /* @__PURE__ */ x(
+            Ce,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "expand",
+              isDisabled: $,
+              children: U ? (
+                // TODO:Button does not occupy the whole height
+                /* @__PURE__ */ x(
+                  nt,
+                  {
+                    w: "100%",
+                    h: "100%",
+                    unstyled: !0,
+                    borderRadius: "0",
+                    "aria-label": N ? "Collapse" : "Expand",
+                    onPress: () => d(t.id),
+                    children: N ? /* @__PURE__ */ x(rn, {}) : /* @__PURE__ */ x(an, {})
+                  }
+                )
+              ) : null
+            }
+          ),
+          /* @__PURE__ */ x(Be, { items: o, children: (w) => {
+            const T = w.accessor(t);
+            return /* @__PURE__ */ x(Ce, { isDisabled: $, children: /* @__PURE__ */ x(
+              oe,
+              {
+                className: m ? "truncated-cell" : "",
+                "data-truncated": m ? "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: ue(T),
+                  row: t,
+                  column: w
+                }) : ue(T)
+              }
+            ) }, w.id);
+          } }),
+          /* @__PURE__ */ x(
+            Ce,
+            {
+              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(Ge.Root, { children: [
+                    /* @__PURE__ */ x(
+                      nt,
+                      {
+                        size: "2xs",
+                        variant: "ghost",
+                        "aria-label": F ? "Unpin row" : "Pin row",
+                        colorPalette: "primary",
+                        onPress: () => g(t.id),
+                        children: /* @__PURE__ */ x(sn, {})
+                      },
+                      "pin-btn"
+                    ),
+                    /* @__PURE__ */ x(Ge.Content, { placement: "top", children: F ? "Unpin row" : "Pin row" })
+                  ] })
+                }
+              )
+            }
+          )
+        ]
+      }
+    ) }),
+    f && /* @__PURE__ */ x(Vt, { ...y, asChild: !0, children: /* @__PURE__ */ x(
+      It,
+      {
+        "data-nested-row-expanded": N ? "true" : "false",
+        dependencies: [N],
+        children: /* @__PURE__ */ x(
+          Ce,
+          {
+            isDisabled: $,
+            colSpan: o.length + (f ? 1 : 0) + (a ? 1 : 0) + 1,
+            "data-nested-cell": !0,
+            children: N ? s && Array.isArray(t[s]) ? `${t[s].length} nested items` : s && t[s] : null
+          }
+        )
+      }
+    ) })
+  ] });
+};
+Ql.displayName = "DataTable.Row";
+const Ci = () => /* @__PURE__ */ x(oe, { w: "100%", p: "200", children: "No Data" }), wt = ({
+  ref: t,
+  "aria-label": e,
+  ...l
+}) => {
+  const n = ie(se), { sortedRows: o, activeColumns: i, renderEmptyState: r } = he(), [d, s] = ke(l), u = e ?? n.format("dataTableBody");
+  return /* @__PURE__ */ x(ci, { asChild: !0, ...d, children: /* @__PURE__ */ x(
+    Qo,
+    {
+      ref: t,
+      "aria-label": u,
+      items: o,
+      dependencies: [i],
+      renderEmptyState: r ?? Ci,
+      ...s,
+      children: (f) => /* @__PURE__ */ x(Ql, { row: f }, f.id)
+    }
+  ) });
+};
+wt.displayName = "DataTable.Body";
+const Dt = function({
+  ref: e,
+  children: l,
+  ...n
+}) {
+  const o = P(null), i = Q(Pe(o, e));
+  return /* @__PURE__ */ x(pi, { ref: i, ...n, children: l });
+};
+Dt.displayName = "DataTable.Footer";
+function wi(t) {
+  return "onRemoveItem" in t && typeof t.onRemoveItem == "function";
+}
+const Di = ({
+  hiddenItems: t,
+  visibleItems: e,
+  handleVisibleColumnsUpdate: l,
+  handleResetColumns: n
+}) => {
+  const [o, i] = Z(""), r = ie(se);
+  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 m = new Set(t.map((b) => b.id)), c = new Set(
+        a.map((b) => b.id)
+      ), p = t.filter(
+        (b) => !c.has(b.id)
+      ), h = a.filter(
+        (b) => !m.has(b.id)
+      );
+      let g = [...e];
+      if (p.length > 0 && (g = [...g, ...p]), 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(Oe, { mt: "800", children: [
+    /* @__PURE__ */ A(xe, { gap: "400", width: "100%", columns: 2, children: [
+      /* @__PURE__ */ A(oe, { children: [
+        /* @__PURE__ */ A(Oe, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(un, {}),
+          /* @__PURE__ */ x(Te, { fontWeight: "700", fontSize: "sm", w: "full", children: r.format("hiddenColumns") })
+        ] }),
+        /* @__PURE__ */ A(
+          Oe,
+          {
+            colorPalette: "primary",
+            border: "{sizes.25} solid",
+            borderColor: "colorPalette.3",
+            borderRadius: "200",
+            gap: "200",
+            p: "300",
+            h: "lg",
+            children: [
+              /* @__PURE__ */ x(
+                yn,
+                {
+                  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(
+                Lt,
+                {
+                  colorPalette: "primary",
+                  border: "{sizes.25} solid",
+                  borderColor: "colorPalette.3"
+                }
+              ),
+              /* @__PURE__ */ x(
+                Le.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(Te, { fontSize: "sm", color: "gray.9", children: r.format("noHiddenColumns") }),
+                  children: (a) => /* @__PURE__ */ x(
+                    Le.Item,
+                    {
+                      py: "100",
+                      id: a.id,
+                      "aria-label": a.label?.toString() ?? a.id,
+                      children: a.label
+                    },
+                    a.id
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ A(oe, { children: [
+        /* @__PURE__ */ A(Oe, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(dn, {}),
+          /* @__PURE__ */ x(Te, { fontWeight: "700", fontSize: "sm", children: r.format("visibleColumnsList") })
+        ] }),
+        /* @__PURE__ */ x(
+          Le.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(
+              Le.Item,
+              {
+                py: "100",
+                id: a.id,
+                onRemoveItem: wi(a) ? a.onRemoveItem : void 0,
+                "aria-label": a.label?.toString() ?? a.id,
+                children: a.label
+              },
+              a.id
+            )
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ x(oe, { children: /* @__PURE__ */ A(
+      xn,
+      {
+        variant: "ghost",
+        colorPalette: "primary",
+        size: "xs",
+        onPress: n,
+        "aria-label": r.format("reset"),
+        children: [
+          /* @__PURE__ */ x(cn, {}),
+          r.format("reset")
+        ]
+      }
+    ) })
+  ] });
+}, Wt = {
+  TOGGLE_TEXT_VISIBILITY: "toggleTextVisibility",
+  TOGGLE_ROW_DENSITY: "toggleRowDensity"
+}, Si = ({
+  onSettingsChange: t
+}) => {
+  const e = ie(se), l = he(), n = l.isTruncated ?? !1, o = l.density === "condensed" ? "compact" : "comfortable", i = (d) => {
+    Array.from(d)[0] && t?.(Wt.TOGGLE_TEXT_VISIBILITY);
+  }, r = (d) => {
+    Array.from(d)[0] && t?.(Wt.TOGGLE_ROW_DENSITY);
+  };
+  return /* @__PURE__ */ A(
+    xe,
+    {
+      templateColumns: "repeat(4, 1fr)",
+      columnGap: "400",
+      rowGap: "600",
+      mt: "800",
+      alignItems: "center",
+      children: [
+        /* @__PURE__ */ x(xe.Item, { colSpan: 1, children: /* @__PURE__ */ x(Te, { fontWeight: "500", children: e.format("textVisibility") }) }),
+        /* @__PURE__ */ x(xe.Item, { colSpan: 3, children: /* @__PURE__ */ x(At, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Tt.Root,
+          {
+            w: "full",
+            selectedKeys: n ? ["preview"] : ["full"],
+            onSelectionChange: i,
+            "aria-label": e.format("textVisibilityAriaLabel"),
+            children: [
+              /* @__PURE__ */ A(
+                je,
+                {
+                  id: "full",
+                  size: "xs",
+                  "aria-label": e.format("fullText"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(fn, {}),
+                    e.format("fullText")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                je,
+                {
+                  id: "preview",
+                  size: "xs",
+                  "aria-label": e.format("textPreviews"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(pn, {}),
+                    e.format("textPreviews")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) }),
+        /* @__PURE__ */ x(xe.Item, { colSpan: 1, children: /* @__PURE__ */ x(Te, { fontWeight: "500", children: e.format("rowDensity") }) }),
+        /* @__PURE__ */ x(xe.Item, { colSpan: 3, children: /* @__PURE__ */ x(At, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Tt.Root,
+          {
+            w: "full",
+            colorPalette: "primary",
+            selectedKeys: [o],
+            onSelectionChange: r,
+            "aria-label": e.format("rowDensityAriaLabel"),
+            children: [
+              /* @__PURE__ */ A(
+                je,
+                {
+                  id: "comfortable",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("comfortable"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(mn, {}),
+                    e.format("comfortable")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                je,
+                {
+                  id: "compact",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("compact"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(hn, {}),
+                    e.format("compact")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) })
+      ]
+    }
+  );
+}, _l = () => {
+  const [t, e] = Z(!1), l = he(), n = ie(se), {
+    columns: o,
+    visibleColumns: i,
+    onColumnsChange: r,
+    onSettingsChange: d
+    // customSettings,
+  } = l, s = o.filter(
+    (y) => !i?.includes(y.id)
+  ), { customSettings: u } = bi(), f = P(o);
+  fe(() => {
+    f.current = o;
+  }, [o]);
+  const a = P(o), m = P(i), c = P(i || []);
+  if (!i || !s)
+    return null;
+  const p = 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 = m.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(Re, { children: [
+    /* @__PURE__ */ A(Ge.Root, { children: [
+      /* @__PURE__ */ x(Ge.Content, { placement: "top", children: n.format("settings") }),
+      /* @__PURE__ */ x(
+        nt,
+        {
+          variant: "ghost",
+          colorPalette: "primary",
+          size: "xs",
+          "aria-label": n.format("settings"),
+          onPress: () => e(!0),
+          children: /* @__PURE__ */ x(bn, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ x(
+      ve.Root,
+      {
+        isOpen: t,
+        onOpenChange: e,
+        placement: "right",
+        "data-testid": "data-table-manager-drawer",
+        children: /* @__PURE__ */ A(
+          ve.Content,
+          {
+            width: "2xl",
+            "data-testid": "data-table-manager-drawer",
+            "aria-label": n.format("settings"),
+            children: [
+              /* @__PURE__ */ A(ve.Header, { children: [
+                /* @__PURE__ */ x(ve.Title, { children: n.format("settings") }),
+                /* @__PURE__ */ x(ve.CloseTrigger, {})
+              ] }),
+              /* @__PURE__ */ x(ve.Body, { children: /* @__PURE__ */ x(
+                Cn.Root,
+                {
+                  tabListAriaLabel: n.format("settingsTabsAriaLabel"),
+                  tabs: [
+                    {
+                      id: "visible-columns",
+                      tabLabel: /* @__PURE__ */ A(Re, { children: [
+                        /* @__PURE__ */ x(gn, {}),
+                        n.format("visibleColumns")
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(
+                        Di,
+                        {
+                          hiddenItems: h,
+                          visibleItems: g,
+                          handleVisibleColumnsUpdate: p,
+                          handleResetColumns: b
+                        }
+                      )
+                    },
+                    {
+                      id: "layout-settings",
+                      tabLabel: /* @__PURE__ */ A(Re, { children: [
+                        /* @__PURE__ */ x(vn, {}),
+                        n.format("layoutSettings")
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(Si, { onSettingsChange: d })
+                    },
+                    u ? {
+                      id: "custom-settings",
+                      tabLabel: /* @__PURE__ */ A(Re, { 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)
+                }
+              ) })
+            ]
+          }
+        )
+      }
+    )
+  ] });
+};
+_l.displayName = "DataTable.Manager";
+const Ei = function({
+  ref: e,
+  footer: l,
+  ...n
+}) {
+  const o = ie(se), i = P(null), r = Q(Pe(i, e));
+  return /* @__PURE__ */ A($t, { ref: r, ...n, children: [
+    /* @__PURE__ */ A(xt, { "aria-label": o.format("dataTable"), children: [
+      /* @__PURE__ */ x(Ct, { "aria-label": o.format("dataTableHeader") }),
+      /* @__PURE__ */ x(wt, { "aria-label": o.format("dataTableBody") })
+    ] }),
+    l && /* @__PURE__ */ x(Dt, { children: l })
+  ] });
+}, Nr = /* @__PURE__ */ Object.assign(Ei, {
+  /**
+   * # 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: $t,
+  /**
+   * # 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: xt,
+  /**
+   * # 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: Ct,
+  /**
+   * # 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: wt,
+  /**
+   * # 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: Dt,
+  /**
+   * # 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: _l,
+  /**
+   * # 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: _e,
+  /**
+   * # 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: he
+});
+export {
+  Nr as D,
+  Wt as U,
+  wt as a,
+  Dt as b,
+  Ct as c,
+  _l as d,
+  $t as e,
+  xt as f
+};
+//# sourceMappingURL=data-table-DlcR-8aA.es.js.map