@commercetools/nimbus 2.0.1 → 2.2.0

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

@@ -0,0 +1,4409 @@
+import { jsx as x, jsxs as A, Fragment as ze } from "react/jsx-runtime";
+import E, { useRef as T, useMemo as K, useCallback as V, useEffect as se, useState as X, forwardRef as Ue, createContext as ue, useContext as B } from "react";
+import { createSlotRecipeContext as Jl, mergeRefs as Pe } from "@chakra-ui/react";
+import { n as Ee, u as he } from "./normalize-messages-D5T4I93D.es.js";
+import { ArrowDownward as Ql, KeyboardArrowDown as _l, KeyboardArrowRight as en, PushPin as tn, VisibilityOff as ln, Visibility as nn, Refresh as on, WrapText as rn, ShortText as an, DensitySmall as sn, FormatAlignJustify as un, Settings as dn, ViewWeek as cn, ViewDay as fn } from "@commercetools/nimbus-icons";
+import { S as xe } from "./simple-grid-DU5v66TG.es.js";
+import { S as pn } from "./search-input-BDUJ48BC.es.js";
+import { $ as mn, D as Ve } from "./draggable-list-z7a7tu_F.es.js";
+import { S as He } from "./stack-CoNreM7B.es.js";
+import { B as ne } from "./box-DuBoAZvq.es.js";
+import { T as Re } from "./text-CIb_VDvO.es.js";
+import { S as Nt } from "./separator-BJ9k_D4l.es.js";
+import { B as hn } from "./button-BEJnxXsL.es.js";
+import { I as We } from "./icon-toggle-button-8fX8JAXp.es.js";
+import { T as wt } from "./toolbar-C7-6gqba.es.js";
+import { T as Dt } from "./toggle-button-group-BWpmMkEz.es.js";
+import { D as ve } from "./drawer-BPcEUbUt.es.js";
+import { T as bn } from "./tabs-D0OPeQ_J.es.js";
+import { T as Oe } from "./tooltip-D3QrrizN.es.js";
+import { I as Ft } from "./icon-button-CosIm3oY.es.js";
+import { $ as J } from "./useObjectRef-CaJ5pgjX.es.js";
+import { $ as It } from "./Button-BjcDZ5eb.es.js";
+import { a as Vt, b as St, c as gn } from "./RSPContexts-DLgb84PF.es.js";
+import { f as W, m as ae, n as re, o as Le, e as vn, g as Ht, $ as Wt, b as yn, a as $n, h as ee, j as Lt } from "./SelectionManager-CX9btso_.es.js";
+import { $ as Ot, a as de, e as Ge, g as kt, d as xn } from "./utils-B6pV5ewr.es.js";
+import { e as De, g as Cn, f as wn, h as Dn, i as Oi } from "./ListBox-RrHJjnuq.es.js";
+import { $ as Sn } from "./intlStrings-Cd44R5hT.es.js";
+import { a as kn, $ as En } from "./SelectionIndicator-B27AsfqE.es.js";
+import { c as tt, $ as jt, g as Te, f as zn, i as Rn, j as An, a as Ye, k as Pn, h as Yi } from "./CollectionBuilder-BOe312C_.es.js";
+import { c as Ae, a as lt, $ as L, e as Tn, d as Et } from "./mergeProps-Dsl8k3Ig.es.js";
+import { $ as te } from "./filterDOMProps-BSVCO5jK.es.js";
+import { c as Bn } from "./OverlayArrow-BIjbCSXk.es.js";
+import { c as ye, a as nt, $ as Kn } from "./scrollIntoView-B7D07fJk.es.js";
+import { b as _i } from "./useListState-Dd0Mtev3.es.js";
+import Mn from "react-dom";
+import { $ as Be } from "./useHover-BQRSM3qT.es.js";
+import { d as zt } from "./platform-Z5fvtFmM.es.js";
+import { a as Nn, b as Fn, $ as Ut } from "./usePress-BuLomD_X.es.js";
+import { $ as In, c as Vn } from "./useFocusable-Cs6i58WP.es.js";
+import { $ as Hn, f as Wn } from "./useFocusVisible-B3HmFL2Q.es.js";
+import { $ as _ } from "./focusSafely-Cwb0Tyy6.es.js";
+import { a as Rt, b as Ln } from "./FocusScope-CqEZq7sr.es.js";
+import { $ as $e } from "./getScrollParent-MZgwmCKW.es.js";
+import { $ as Se } from "./context-DW7UvQ8z.es.js";
+import { $ as Ke } from "./useLocalizedStringFormatter-DWb0DkHL.es.js";
+import { $ as we } from "./useFocusRing-FPt2Rwil.es.js";
+import { $ as On } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { a as Xe, $ as At } from "./VisuallyHidden-BLRzeMsq.es.js";
+import { e as jn } from "./openLink-BNz58j4a.es.js";
+import { m as je } from "./utils-oAGBWzI5.es.js";
+import { e as Un, c as Gn } from "./Header-CiYtrnTw.es.js";
+import { $ as Yn } from "./LiveAnnouncer-CsPyaceH.es.js";
+import { d as Xn, e as qn } from "./useGridListItem-CJrr2QNO.es.js";
+import { $ as Gt } from "./useCollator-BjnMaGJd.es.js";
+import { $ as Zn } from "./useHasTabbableChild-DXq72IE3.es.js";
+import { $ as Jn } from "./useUpdateEffect-CCDx8D4X.es.js";
+import { e as ke } from "./extract-style-props-BdibuNZ7.es.js";
+import { Highlight as Qn } from "@chakra-ui/react/highlight";
+import { C as Yt } from "./checkbox-CputcCVr.es.js";
+import { Flex as _n } from "@chakra-ui/react/flex";
+function eo(t) {
+  let { onMoveStart: e, onMove: l, onMoveEnd: n } = t, o = T({
+    didMove: !1,
+    lastPosition: null,
+    id: null
+  }), { addGlobalListener: i, removeGlobalListener: a } = On(), s = Ae((c, r, p, f) => {
+    p === 0 && f === 0 || (o.current.didMove || (o.current.didMove = !0, e?.({
+      type: "movestart",
+      pointerType: r,
+      shiftKey: c.shiftKey,
+      metaKey: c.metaKey,
+      ctrlKey: c.ctrlKey,
+      altKey: c.altKey
+    })), l?.({
+      type: "move",
+      pointerType: r,
+      deltaX: p,
+      deltaY: f,
+      shiftKey: c.shiftKey,
+      metaKey: c.metaKey,
+      ctrlKey: c.ctrlKey,
+      altKey: c.altKey
+    }));
+  }), u = Ae((c, r) => {
+    Nn(), o.current.didMove && n?.({
+      type: "moveend",
+      pointerType: r,
+      shiftKey: c.shiftKey,
+      metaKey: c.metaKey,
+      ctrlKey: c.ctrlKey,
+      altKey: c.altKey
+    });
+  });
+  return {
+    moveProps: K(() => {
+      let c = {}, r = () => {
+        Fn(), o.current.didMove = !1;
+      };
+      if (typeof PointerEvent > "u" && process.env.NODE_ENV === "test") {
+        let f = (v) => {
+          if (v.button === 0) {
+            var $, b, C, g;
+            s(v, "mouse", v.pageX - ((C = ($ = o.current.lastPosition) === null || $ === void 0 ? void 0 : $.pageX) !== null && C !== void 0 ? C : 0), v.pageY - ((g = (b = o.current.lastPosition) === null || b === void 0 ? void 0 : b.pageY) !== null && g !== void 0 ? g : 0)), o.current.lastPosition = {
+              pageX: v.pageX,
+              pageY: v.pageY
+            };
+          }
+        }, m = (v) => {
+          v.button === 0 && (u(v, "mouse"), a(window, "mousemove", f, !1), a(window, "mouseup", m, !1));
+        };
+        c.onMouseDown = (v) => {
+          v.button === 0 && (r(), v.stopPropagation(), v.preventDefault(), o.current.lastPosition = {
+            pageX: v.pageX,
+            pageY: v.pageY
+          }, i(window, "mousemove", f, !1), i(window, "mouseup", m, !1));
+        };
+        let h = (v) => {
+          let $ = [
+            ...v.changedTouches
+          ].findIndex(({ identifier: D }) => D === o.current.id);
+          if ($ >= 0) {
+            var b, C;
+            let { pageX: D, pageY: R } = v.changedTouches[$];
+            var g, w;
+            s(v, "touch", D - ((g = (b = o.current.lastPosition) === null || b === void 0 ? void 0 : b.pageX) !== null && g !== void 0 ? g : 0), R - ((w = (C = o.current.lastPosition) === null || C === void 0 ? void 0 : C.pageY) !== null && w !== void 0 ? w : 0)), o.current.lastPosition = {
+              pageX: D,
+              pageY: R
+            };
+          }
+        }, y = (v) => {
+          [
+            ...v.changedTouches
+          ].findIndex(({ identifier: b }) => b === o.current.id) >= 0 && (u(v, "touch"), o.current.id = null, a(window, "touchmove", h), a(window, "touchend", y), a(window, "touchcancel", y));
+        };
+        c.onTouchStart = (v) => {
+          if (v.changedTouches.length === 0 || o.current.id != null) return;
+          let { pageX: $, pageY: b, identifier: C } = v.changedTouches[0];
+          r(), v.stopPropagation(), v.preventDefault(), o.current.lastPosition = {
+            pageX: $,
+            pageY: b
+          }, o.current.id = C, i(window, "touchmove", h, !1), i(window, "touchend", y, !1), i(window, "touchcancel", y, !1);
+        };
+      } else {
+        let f = (h) => {
+          if (h.pointerId === o.current.id) {
+            var y, v;
+            let C = h.pointerType || "mouse";
+            var $, b;
+            s(h, C, h.pageX - (($ = (y = o.current.lastPosition) === null || y === void 0 ? void 0 : y.pageX) !== null && $ !== void 0 ? $ : 0), h.pageY - ((b = (v = o.current.lastPosition) === null || v === void 0 ? void 0 : v.pageY) !== null && b !== void 0 ? b : 0)), o.current.lastPosition = {
+              pageX: h.pageX,
+              pageY: h.pageY
+            };
+          }
+        }, m = (h) => {
+          if (h.pointerId === o.current.id) {
+            let y = h.pointerType || "mouse";
+            u(h, y), o.current.id = null, a(window, "pointermove", f, !1), a(window, "pointerup", m, !1), a(window, "pointercancel", m, !1);
+          }
+        };
+        c.onPointerDown = (h) => {
+          h.button === 0 && o.current.id == null && (r(), h.stopPropagation(), h.preventDefault(), o.current.lastPosition = {
+            pageX: h.pageX,
+            pageY: h.pageY
+          }, o.current.id = h.pointerId, i(window, "pointermove", f, !1), i(window, "pointerup", m, !1), i(window, "pointercancel", m, !1));
+        };
+      }
+      let p = (f, m, h) => {
+        r(), s(f, "keyboard", m, h), u(f, "keyboard");
+      };
+      return c.onKeyDown = (f) => {
+        switch (f.key) {
+          case "Left":
+          case "ArrowLeft":
+            f.preventDefault(), f.stopPropagation(), p(f, -1, 0);
+            break;
+          case "Right":
+          case "ArrowRight":
+            f.preventDefault(), f.stopPropagation(), p(f, 1, 0);
+            break;
+          case "Up":
+          case "ArrowUp":
+            f.preventDefault(), f.stopPropagation(), p(f, 0, -1);
+            break;
+          case "Down":
+          case "ArrowDown":
+            f.preventDefault(), f.stopPropagation(), p(f, 0, 1);
+            break;
+        }
+      }, c;
+    }, [
+      o,
+      i,
+      a,
+      s,
+      u
+    ])
+  };
+}
+class Xt {
+  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 s of W(n, this.collection)) {
+      var i;
+      if (s.colSpan && s.colSpan + o > l) return (i = s.key) !== null && i !== void 0 ? i : null;
+      s.colSpan && (o = o + s.colSpan - 1);
+      var a;
+      if (o === l) return (a = s.key) !== null && a !== void 0 ? a : 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 c = W(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = ae(c)) === null || n === void 0 ? void 0 : n.key : (o = re(c)) === null || o === void 0 ? void 0 : o.key) !== null && i !== void 0 ? i : null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let c = this.collection.getItem(l.parentKey);
+      if (!c) return null;
+      let r = W(c, this.collection);
+      var a;
+      let p = (a = this.direction === "rtl" ? Le(r, l.index - 1) : Le(r, l.index + 1)) !== null && a !== void 0 ? a : null;
+      var s;
+      if (p) return (s = p.key) !== null && s !== void 0 ? s : null;
+      var u;
+      if (this.focusMode === "row") return (u = l.parentKey) !== null && u !== void 0 ? u : null;
+      var d;
+      return (d = this.direction === "rtl" ? this.getFirstKey(e) : this.getLastKey(e)) !== null && d !== void 0 ? d : null;
+    }
+    return null;
+  }
+  getKeyLeftOf(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (this.isRow(l)) {
+      var n, o;
+      let c = W(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = re(c)) === null || n === void 0 ? void 0 : n.key : (o = ae(c)) === null || o === void 0 ? void 0 : o.key) !== null && i !== void 0 ? i : null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let c = this.collection.getItem(l.parentKey);
+      if (!c) return null;
+      let r = W(c, this.collection);
+      var a;
+      let p = (a = this.direction === "rtl" ? Le(r, l.index + 1) : Le(r, l.index - 1)) !== null && a !== void 0 ? a : null;
+      var s;
+      if (p) return (s = p.key) !== null && s !== void 0 ? s : null;
+      var u;
+      if (this.focusMode === "row") return (u = l.parentKey) !== null && u !== void 0 ? u : null;
+      var d;
+      return (d = this.direction === "rtl" ? this.getLastKey(e) : this.getFirstKey(e)) !== null && d !== void 0 ? d : 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 d = this.collection.getItem(o.parentKey);
+        if (!d) return null;
+        var a;
+        return (a = (i = re(W(d, this.collection))) === null || i === void 0 ? void 0 : i.key) !== null && a !== void 0 ? a : null;
+      }
+    }
+    if (n = this.findNextKey(void 0, (d) => d.type === "item"), n != null && (o && this.isCell(o) && l || this.focusMode === "cell")) {
+      var s;
+      let d = this.collection.getItem(n);
+      if (!d) return null;
+      var u;
+      n = (u = (s = re(W(d, this.collection))) === null || s === void 0 ? void 0 : s.key) !== null && u !== void 0 ? u : 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 d = this.collection.getItem(o.parentKey);
+        if (!d) return null;
+        let c = W(d, this.collection);
+        var a;
+        return (a = (i = ae(c)) === null || i === void 0 ? void 0 : i.key) !== null && a !== void 0 ? a : null;
+      }
+    }
+    if (n = this.findPreviousKey(void 0, (d) => d.type === "item"), n != null && (o && this.isCell(o) && l || this.focusMode === "cell")) {
+      var s;
+      let d = this.collection.getItem(n);
+      if (!d) return null;
+      let c = W(d, this.collection);
+      var u;
+      n = (u = (s = ae(c)) === null || s === void 0 ? void 0 : s.key) !== null && u !== void 0 ? u : 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 a = this.getKeyBelow(l);
+      if (a == null) break;
+      n = this.layoutDelegate.getItemRect(a), l = a;
+    }
+    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 a;
+    i.type === "cell" && (n = (a = i.parentKey) !== null && a !== void 0 ? a : null);
+    let s = !1;
+    for (; n != null; ) {
+      let c = o.getItem(n);
+      if (!c) return null;
+      if (c.textValue) {
+        let r = c.textValue.slice(0, e.length);
+        if (this.collator.compare(r, e) === 0) {
+          var u, d;
+          return this.isRow(c) && this.focusMode === "cell" ? (d = (u = re(W(c, this.collection))) === null || u === void 0 ? void 0 : u.key) !== null && d !== void 0 ? d : null : c.key;
+        }
+      }
+      n = this.findNextKey(n, (r) => r.type === "item"), n == null && !s && (n = this.getFirstKey(), s = !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 to(e.layout) : new Un(e.ref));
+    var l;
+    this.focusMode = (l = e.focusMode) !== null && l !== void 0 ? l : "row";
+  }
+}
+class to {
+  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 ot = /* @__PURE__ */ new WeakMap();
+function lo(t, e, l) {
+  let { isVirtualized: n, disallowTypeAhead: o, keyboardDelegate: i, focusMode: a, scrollRef: s, getRowText: u, onRowAction: d, onCellAction: c, escapeKeyBehavior: r = "clearSelection", shouldSelectOnPressUp: p } = t, { selectionManager: f } = e;
+  !t["aria-label"] && !t["aria-labelledby"] && console.warn("An aria-label or aria-labelledby prop is required for accessibility.");
+  let m = Gt({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: h } = Se(), y = e.selectionManager.disabledBehavior, v = K(() => i || new Xt({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: y,
+    ref: l,
+    direction: h,
+    collator: m,
+    focusMode: a
+  }), [
+    i,
+    e.collection,
+    e.disabledKeys,
+    y,
+    l,
+    h,
+    m,
+    a
+  ]), { collectionProps: $ } = vn({
+    ref: l,
+    selectionManager: f,
+    keyboardDelegate: v,
+    isVirtualized: n,
+    scrollRef: s,
+    disallowTypeAhead: o,
+    escapeKeyBehavior: r
+  }), b = lt(t.id);
+  ot.set(e, {
+    keyboardDelegate: v,
+    actions: {
+      onRowAction: d,
+      onCellAction: c
+    },
+    shouldSelectOnPressUp: p
+  });
+  let C = Xn({
+    selectionManager: f,
+    hasItemActions: !!(d || c)
+  }), g = te(t, {
+    labelable: !0
+  }), w = V((z) => {
+    if (f.isFocused) {
+      z.currentTarget.contains(z.target) || f.setFocused(!1);
+      return;
+    }
+    z.currentTarget.contains(z.target) && f.setFocused(!0);
+  }, [
+    f
+  ]), D = K(() => ({
+    onBlur: $.onBlur,
+    onFocus: w
+  }), [
+    w,
+    $.onBlur
+  ]), R = Zn(l, {
+    isDisabled: e.collection.size !== 0
+  }), P = L(
+    g,
+    {
+      role: "grid",
+      id: b,
+      "aria-multiselectable": f.selectionMode === "multiple" ? "true" : void 0
+    },
+    e.isKeyboardNavigationDisabled ? D : $,
+    // If collection is empty, make sure the grid is tabbable unless there is a child tabbable element.
+    e.collection.size === 0 && {
+      tabIndex: R ? -1 : 0
+    } || void 0,
+    C
+  );
+  return n && (P["aria-rowcount"] = e.collection.size, P["aria-colcount"] = e.collection.columnCount), qn({
+    getRowText: u
+  }, e), {
+    gridProps: P
+  };
+}
+function no() {
+  return {
+    rowGroupProps: {
+      role: "rowgroup"
+    }
+  };
+}
+function oo(t, e, l) {
+  var n, o;
+  let { node: i, isVirtualized: a, shouldSelectOnPressUp: s, onAction: u } = t, { actions: d, shouldSelectOnPressUp: c } = ot.get(e), r = d.onRowAction ? () => {
+    var y;
+    return (y = d.onRowAction) === null || y === void 0 ? void 0 : y.call(d, i.key);
+  } : u, { itemProps: p, ...f } = Ht({
+    selectionManager: e.selectionManager,
+    key: i.key,
+    ref: l,
+    isVirtualized: a,
+    shouldSelectOnPressUp: c || s,
+    onAction: r || !(i == null || (n = i.props) === null || n === void 0) && n.onAction ? Tn(i == null || (o = i.props) === null || o === void 0 ? void 0 : o.onAction, r) : void 0,
+    isDisabled: e.collection.size === 0
+  }), m = e.selectionManager.isSelected(i.key), h = {
+    role: "row",
+    "aria-selected": e.selectionManager.selectionMode !== "none" ? m : void 0,
+    "aria-disabled": f.isDisabled || void 0,
+    ...p
+  };
+  return a && (h["aria-rowindex"] = i.index + 1), {
+    rowProps: h,
+    ...f
+  };
+}
+function qt(t, e, l) {
+  let { node: n, isVirtualized: o, focusMode: i = "child", shouldSelectOnPressUp: a, onAction: s } = t, { direction: u } = Se(), { keyboardDelegate: d, actions: { onCellAction: c } } = ot.get(e), r = T(null), p = () => {
+    if (l.current) {
+      let b = Rt(l.current);
+      if (i === "child") {
+        if (l.current.contains(document.activeElement) && l.current !== document.activeElement) return;
+        let C = e.selectionManager.childFocusStrategy === "last" ? Je(b) : b.firstChild();
+        if (C) {
+          _(C);
+          return;
+        }
+      }
+      (r.current != null && n.key !== r.current || !l.current.contains(document.activeElement)) && _(l.current);
+    }
+  }, { itemProps: f, isPressed: m } = Ht({
+    selectionManager: e.selectionManager,
+    key: n.key,
+    ref: l,
+    isVirtualized: o,
+    focus: p,
+    shouldSelectOnPressUp: a,
+    onAction: c ? () => c(n.key) : s,
+    isDisabled: e.collection.size === 0
+  }), h = (b) => {
+    if (!b.currentTarget.contains(b.target) || e.isKeyboardNavigationDisabled || !l.current || !document.activeElement) return;
+    let C = Rt(l.current);
+    switch (C.currentNode = document.activeElement, b.key) {
+      case "ArrowLeft": {
+        let z = u === "rtl" ? C.nextNode() : C.previousNode();
+        if (i === "child" && z === l.current && (z = null), b.preventDefault(), b.stopPropagation(), z)
+          _(z), ye(z, {
+            containingElement: $e(l.current)
+          });
+        else {
+          var g;
+          if (((g = d.getKeyLeftOf) === null || g === void 0 ? void 0 : g.call(d, n.key)) !== n.key) {
+            var w;
+            (w = l.current.parentElement) === null || w === void 0 || w.dispatchEvent(new KeyboardEvent(b.nativeEvent.type, b.nativeEvent));
+            break;
+          }
+          i === "cell" && u === "rtl" ? (_(l.current), ye(l.current, {
+            containingElement: $e(l.current)
+          })) : (C.currentNode = l.current, z = u === "rtl" ? C.firstChild() : Je(C), z && (_(z), ye(z, {
+            containingElement: $e(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowRight": {
+        let z = u === "rtl" ? C.previousNode() : C.nextNode();
+        if (i === "child" && z === l.current && (z = null), b.preventDefault(), b.stopPropagation(), z)
+          _(z), ye(z, {
+            containingElement: $e(l.current)
+          });
+        else {
+          var D;
+          if (((D = d.getKeyRightOf) === null || D === void 0 ? void 0 : D.call(d, n.key)) !== n.key) {
+            var R;
+            (R = l.current.parentElement) === null || R === void 0 || R.dispatchEvent(new KeyboardEvent(b.nativeEvent.type, b.nativeEvent));
+            break;
+          }
+          i === "cell" && u === "ltr" ? (_(l.current), ye(l.current, {
+            containingElement: $e(l.current)
+          })) : (C.currentNode = l.current, z = u === "rtl" ? Je(C) : C.firstChild(), z && (_(z), ye(z, {
+            containingElement: $e(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowUp":
+      case "ArrowDown":
+        if (!b.altKey && l.current.contains(b.target)) {
+          var P;
+          b.stopPropagation(), b.preventDefault(), (P = l.current.parentElement) === null || P === void 0 || P.dispatchEvent(new KeyboardEvent(b.nativeEvent.type, b.nativeEvent));
+        }
+        break;
+    }
+  }, y = (b) => {
+    if (r.current = n.key, b.target !== l.current) {
+      Hn() || e.selectionManager.setFocusedKey(n.key);
+      return;
+    }
+    requestAnimationFrame(() => {
+      i === "child" && document.activeElement === l.current && p();
+    });
+  }, v = L(f, {
+    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: y
+  });
+  var $;
+  return o && (v["aria-colindex"] = (($ = n.colIndex) !== null && $ !== void 0 ? $ : n.index) + 1), a && v.tabIndex != null && v.onPointerDown == null && (v.onPointerDown = (b) => {
+    let C = b.currentTarget, g = C.getAttribute("tabindex");
+    C.removeAttribute("tabindex"), requestAnimationFrame(() => {
+      g != null && C.setAttribute("tabindex", g);
+    });
+  }), {
+    gridCellProps: v,
+    isPressed: m
+  };
+}
+function Je(t) {
+  let e = null, l = null;
+  do
+    l = t.lastChild(), l && (e = l);
+  while (l);
+  return e;
+}
+const it = /* @__PURE__ */ new WeakMap();
+function Qe(t) {
+  return typeof t == "string" ? t.replace(/\s*/g, "") : "" + t;
+}
+function Zt(t, e) {
+  let l = it.get(t);
+  if (!l) throw new Error("Unknown grid");
+  return `${l}-${Qe(e)}`;
+}
+function Jt(t, e, l) {
+  let n = it.get(t);
+  if (!n) throw new Error("Unknown grid");
+  return `${n}-${Qe(e)}-${Qe(l)}`;
+}
+function Qt(t, e) {
+  return [
+    ...t.collection.rowHeaderColumnKeys
+  ].map((l) => Jt(t, e, l)).join(" ");
+}
+var _t = {};
+_t = {
+  ascending: "تصاعدي",
+  ascendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تصاعدي`,
+  columnSize: (t) => `${t.value} بالبكسل`,
+  descending: "تنازلي",
+  descendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تنازلي`,
+  resizerDescription: "اضغط على مفتاح Enter لبدء تغيير الحجم",
+  select: "تحديد",
+  selectAll: "تحديد الكل",
+  sortable: "عمود قابل للترتيب"
+};
+var el = {};
+el = {
+  ascending: "възходящ",
+  ascendingSort: (t) => `сортирано по колона ${t.columnName} във възходящ ред`,
+  columnSize: (t) => `${t.value} пиксела`,
+  descending: "низходящ",
+  descendingSort: (t) => `сортирано по колона ${t.columnName} в низходящ ред`,
+  resizerDescription: "Натиснете „Enter“, за да започнете да преоразмерявате",
+  select: "Изберете",
+  selectAll: "Изберете всичко",
+  sortable: "сортираща колона"
+};
+var tl = {};
+tl = {
+  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 ll = {};
+ll = {
+  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 nl = {};
+nl = {
+  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 ol = {};
+ol = {
+  ascending: "αύξουσα",
+  ascendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε αύξουσα σειρά`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "φθίνουσα",
+  descendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε φθίνουσα σειρά`,
+  resizerDescription: "Πατήστε Enter για έναρξη της αλλαγής μεγέθους",
+  select: "Επιλογή",
+  selectAll: "Επιλογή όλων",
+  sortable: "Στήλη διαλογής"
+};
+var il = {};
+il = {
+  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 rl = {};
+rl = {
+  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 al = {};
+al = {
+  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 sl = {};
+sl = {
+  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 ul = {};
+ul = {
+  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 dl = {};
+dl = {
+  ascending: "עולה",
+  ascendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר עולה`,
+  columnSize: (t) => `${t.value} פיקסלים`,
+  descending: "יורד",
+  descendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר יורד`,
+  resizerDescription: "הקש Enter כדי לשנות את הגודל",
+  select: "בחר",
+  selectAll: "בחר הכול",
+  sortable: "עמודה שניתן למיין"
+};
+var cl = {};
+cl = {
+  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 fl = {};
+fl = {
+  ascending: "növekvő",
+  ascendingSort: (t) => `rendezve a(z) ${t.columnName} oszlop szerint, növekvő sorrendben`,
+  columnSize: (t) => `${t.value} képpont`,
+  descending: "csökkenő",
+  descendingSort: (t) => `rendezve a(z) ${t.columnName} oszlop szerint, csökkenő sorrendben`,
+  resizerDescription: "Nyomja le az Enter billentyűt az átméretezés megkezdéséhez",
+  select: "Kijelölés",
+  selectAll: "Összes kijelölése",
+  sortable: "rendezendő oszlop"
+};
+var pl = {};
+pl = {
+  ascending: "crescente",
+  ascendingSort: (t) => `in ordine crescente in base alla colonna ${t.columnName}`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "decrescente",
+  descendingSort: (t) => `in ordine decrescente in base alla colonna ${t.columnName}`,
+  resizerDescription: "Premi Invio per iniziare a ridimensionare",
+  select: "Seleziona",
+  selectAll: "Seleziona tutto",
+  sortable: "colonna ordinabile"
+};
+var ml = {};
+ml = {
+  ascending: "昇順",
+  ascendingSort: (t) => `列 ${t.columnName} を昇順で並べ替え`,
+  columnSize: (t) => `${t.value} ピクセル`,
+  descending: "降順",
+  descendingSort: (t) => `列 ${t.columnName} を降順で並べ替え`,
+  resizerDescription: "Enter キーを押してサイズ変更を開始",
+  select: "選択",
+  selectAll: "すべて選択",
+  sortable: "並べ替え可能な列"
+};
+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: "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 gl = {};
+gl = {
+  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 vl = {};
+vl = {
+  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 yl = {};
+yl = {
+  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 $l = {};
+$l = {
+  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 xl = {};
+xl = {
+  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 Cl = {};
+Cl = {
+  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 wl = {};
+wl = {
+  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 Dl = {};
+Dl = {
+  ascending: "возрастание",
+  ascendingSort: (t) => `сортировать столбец ${t.columnName} в порядке возрастания`,
+  columnSize: (t) => `${t.value} пикс.`,
+  descending: "убывание",
+  descendingSort: (t) => `сортировать столбец ${t.columnName} в порядке убывания`,
+  resizerDescription: "Нажмите клавишу Enter для начала изменения размеров",
+  select: "Выбрать",
+  selectAll: "Выбрать все",
+  sortable: "сортируемый столбец"
+};
+var Sl = {};
+Sl = {
+  ascending: "vzostupne",
+  ascendingSort: (t) => `zoradené zostupne podľa stĺpca ${t.columnName}`,
+  columnSize: (t) => `Počet pixelov: ${t.value}`,
+  descending: "zostupne",
+  descendingSort: (t) => `zoradené zostupne podľa stĺpca ${t.columnName}`,
+  resizerDescription: "Stlačením klávesu Enter začnete zmenu veľkosti",
+  select: "Vybrať",
+  selectAll: "Vybrať všetko",
+  sortable: "zoraditeľný stĺpec"
+};
+var kl = {};
+kl = {
+  ascending: "naraščajoče",
+  ascendingSort: (t) => `razvrščeno po stolpcu ${t.columnName} v naraščajočem vrstnem redu`,
+  columnSize: (t) => `${t.value} slikovnih pik`,
+  descending: "padajoče",
+  descendingSort: (t) => `razvrščeno po stolpcu ${t.columnName} v padajočem vrstnem redu`,
+  resizerDescription: "Pritisnite tipko Enter da začnete spreminjati velikost",
+  select: "Izberite",
+  selectAll: "Izberite vse",
+  sortable: "razvrstljivi stolpec"
+};
+var El = {};
+El = {
+  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 zl = {};
+zl = {
+  ascending: "stigande",
+  ascendingSort: (t) => `sorterat på kolumn ${t.columnName} i stigande ordning`,
+  columnSize: (t) => `${t.value} pixlar`,
+  descending: "fallande",
+  descendingSort: (t) => `sorterat på kolumn ${t.columnName} i fallande ordning`,
+  resizerDescription: "Tryck på Retur för att börja ändra storlek",
+  select: "Markera",
+  selectAll: "Markera allt",
+  sortable: "sorterbar kolumn"
+};
+var Rl = {};
+Rl = {
+  ascending: "artan sırada",
+  ascendingSort: (t) => `${t.columnName} sütuna göre artan düzende sırala`,
+  columnSize: (t) => `${t.value} piksel`,
+  descending: "azalan sırada",
+  descendingSort: (t) => `${t.columnName} sütuna göre azalan düzende sırala`,
+  resizerDescription: "Yeniden boyutlandırmak için Enter'a basın",
+  select: "Seç",
+  selectAll: "Tümünü Seç",
+  sortable: "Sıralanabilir sütun"
+};
+var Al = {};
+Al = {
+  ascending: "висхідний",
+  ascendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у висхідному порядку`,
+  columnSize: (t) => `${t.value} пікс.`,
+  descending: "низхідний",
+  descendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у низхідному порядку`,
+  resizerDescription: "Натисніть Enter, щоб почати зміну розміру",
+  select: "Вибрати",
+  selectAll: "Вибрати все",
+  sortable: "сортувальний стовпець"
+};
+var Pl = {};
+Pl = {
+  ascending: "升序",
+  ascendingSort: (t) => `按列 ${t.columnName} 升序排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "降序",
+  descendingSort: (t) => `按列 ${t.columnName} 降序排序`,
+  resizerDescription: "按“输入”键开始调整大小。",
+  select: "选择",
+  selectAll: "全选",
+  sortable: "可排序的列"
+};
+var Tl = {};
+Tl = {
+  ascending: "遞增",
+  ascendingSort: (t) => `已依據「${t.columnName}」欄遞增排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "遞減",
+  descendingSort: (t) => `已依據「${t.columnName}」欄遞減排序`,
+  resizerDescription: "按 Enter 鍵以開始調整大小",
+  select: "選取",
+  selectAll: "全選",
+  sortable: "可排序的欄"
+};
+var Me = {};
+Me = {
+  "ar-AE": _t,
+  "bg-BG": el,
+  "cs-CZ": tl,
+  "da-DK": ll,
+  "de-DE": nl,
+  "el-GR": ol,
+  "en-US": il,
+  "es-ES": rl,
+  "et-EE": al,
+  "fi-FI": sl,
+  "fr-FR": ul,
+  "he-IL": dl,
+  "hr-HR": cl,
+  "hu-HU": fl,
+  "it-IT": pl,
+  "ja-JP": ml,
+  "ko-KR": hl,
+  "lt-LT": bl,
+  "lv-LV": gl,
+  "nb-NO": vl,
+  "nl-NL": yl,
+  "pl-PL": $l,
+  "pt-BR": xl,
+  "pt-PT": Cl,
+  "ro-RO": wl,
+  "ru-RU": Dl,
+  "sk-SK": Sl,
+  "sl-SI": kl,
+  "sr-SP": El,
+  "sv-SE": zl,
+  "tr-TR": Rl,
+  "uk-UA": Al,
+  "zh-CN": Pl,
+  "zh-TW": Tl
+};
+class io extends Xt {
+  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 = re(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 a = o[i];
+      if (a.type === "column") return a.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 a;
+    i?.type === "cell" && (o = (a = i.parentKey) !== null && a !== void 0 ? a : null);
+    let s = !1;
+    for (; o != null; ) {
+      let u = n.getItem(o);
+      if (!u) return null;
+      if (u.textValue) {
+        let d = u.textValue.slice(0, e.length);
+        if (this.collator.compare(d, e) === 0) return u.key;
+      }
+      for (let d of W(u, this.collection)) {
+        let c = n.columns[d.index];
+        if (n.rowHeaderColumnKeys.has(c.key) && d.textValue) {
+          let r = d.textValue.slice(0, e.length);
+          if (this.collator.compare(r, e) === 0) {
+            let p = l != null ? n.getItem(l) : i;
+            return p?.type === "cell" ? d.key : u.key;
+          }
+        }
+      }
+      o = this.getKeyBelow(o), o == null && !s && (o = this.getFirstKey(), s = !0);
+    }
+    return null;
+  }
+}
+function ro(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function ao(t, e, l) {
+  let { keyboardDelegate: n, isVirtualized: o, layoutDelegate: i, layout: a } = t, s = Gt({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: u } = Se(), d = e.selectionManager.disabledBehavior, c = K(() => n || new io({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: d,
+    ref: l,
+    direction: u,
+    collator: s,
+    layoutDelegate: i,
+    layout: a
+  }), [
+    n,
+    e.collection,
+    e.disabledKeys,
+    d,
+    l,
+    u,
+    s,
+    i,
+    a
+  ]), r = lt(t.id);
+  it.set(e, r);
+  let { gridProps: p } = lo({
+    ...t,
+    id: r,
+    keyboardDelegate: c
+  }, e, l);
+  o && (p["aria-rowcount"] = e.collection.size + e.collection.headerRows.length), je() && "expandedKeys" in e && (p.role = "treegrid");
+  let { column: f, direction: m } = e.sortDescriptor || {}, h = Ke(ro(Me), "@react-aria/table"), y = K(() => {
+    var $, b;
+    let C = (b = ($ = e.collection.columns.find((g) => g.key === f)) === null || $ === void 0 ? void 0 : $.textValue) !== null && b !== void 0 ? b : "";
+    return m && f ? h.format(`${m}Sort`, {
+      columnName: C
+    }) : void 0;
+  }, [
+    m,
+    f,
+    e.collection.columns
+  ]), v = nt(y);
+  return Jn(() => {
+    y && Yn(y, "assertive", 500);
+  }, [
+    y
+  ]), {
+    gridProps: L(p, v, {
+      // merge sort description with long press information
+      "aria-describedby": [
+        v["aria-describedby"],
+        p["aria-describedby"]
+      ].filter(Boolean).join(" ")
+    })
+  };
+}
+function so(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function uo(t, e, l) {
+  var n, o;
+  let { node: i } = t, a = i.props.allowsSorting, { gridCellProps: s } = qt({
+    ...t,
+    focusMode: "child"
+  }, e, l), u = i.props.isSelectionCell && e.selectionManager.selectionMode === "single", { pressProps: d } = Ut({
+    isDisabled: !a || u,
+    onPress() {
+      e.sort(i.key);
+    },
+    ref: l
+  }), { focusableProps: c } = In({}, l), r, p = ((n = e.sortDescriptor) === null || n === void 0 ? void 0 : n.column) === i.key, f = (o = e.sortDescriptor) === null || o === void 0 ? void 0 : o.direction;
+  i.props.allowsSorting && !zt() && (r = p ? f : "none");
+  let m = Ke(so(Me), "@react-aria/table"), h;
+  a && (h = `${m.format("sortable")}`, p && f && zt() && (h = `${h}, ${m.format(f)}`));
+  let y = nt(h), v = e.collection.size === 0;
+  return se(() => {
+    v && e.selectionManager.focusedKey === i.key && e.selectionManager.setFocusedKey(null);
+  }, [
+    v,
+    e.selectionManager,
+    i.key
+  ]), {
+    columnHeaderProps: {
+      ...L(
+        c,
+        s,
+        d,
+        y,
+        // If the table is empty, make all column headers untabbable
+        v ? {
+          tabIndex: -1
+        } : null
+      ),
+      role: "columnheader",
+      id: Zt(e, i.key),
+      "aria-colspan": i.colSpan && i.colSpan > 1 ? i.colSpan : void 0,
+      "aria-sort": r
+    }
+  };
+}
+const Pt = {
+  expand: {
+    ltr: "ArrowRight",
+    rtl: "ArrowLeft"
+  },
+  collapse: {
+    ltr: "ArrowLeft",
+    rtl: "ArrowRight"
+  }
+};
+function co(t, e, l) {
+  let { node: n, isVirtualized: o } = t, { rowProps: i, ...a } = oo(t, e, l), { direction: s } = Se();
+  o && !(je() && "expandedKeys" in e) ? i["aria-rowindex"] = n.index + 1 + e.collection.headerRows.length : delete i["aria-rowindex"];
+  let u = {};
+  if (je() && "expandedKeys" in e) {
+    let g = e.keyMap.get(n.key);
+    if (g != null) {
+      var d, c, r, p, f, m;
+      let w = ((d = g.props) === null || d === void 0 ? void 0 : d.UNSTABLE_childItems) || ((r = g.props) === null || r === void 0 || (c = r.children) === null || c === void 0 ? void 0 : c.length) > e.userColumnCount;
+      var h, y, v, $;
+      u = {
+        onKeyDown: (D) => {
+          (D.key === Pt.expand[s] && e.selectionManager.focusedKey === g.key && w && e.expandedKeys !== "all" && !e.expandedKeys.has(g.key) || D.key === Pt.collapse[s] && e.selectionManager.focusedKey === g.key && w && (e.expandedKeys === "all" || e.expandedKeys.has(g.key))) && (e.toggleKey(g.key), D.stopPropagation());
+        },
+        "aria-expanded": w ? e.expandedKeys === "all" || e.expandedKeys.has(n.key) : void 0,
+        "aria-level": g.level,
+        "aria-posinset": ((h = g.indexOfType) !== null && h !== void 0 ? h : 0) + 1,
+        "aria-setsize": g.level > 1 ? ((v = (p = ae((y = (f = e.keyMap.get(g.parentKey)) === null || f === void 0 ? void 0 : f.childNodes) !== null && y !== void 0 ? y : [])) === null || p === void 0 ? void 0 : p.indexOfType) !== null && v !== void 0 ? v : 0) + 1 : (($ = (m = ae(e.collection.body.childNodes)) === null || m === void 0 ? void 0 : m.indexOfType) !== null && $ !== void 0 ? $ : 0) + 1
+      };
+    }
+  }
+  let b = jn(n.props), C = a.hasAction ? b : {};
+  return {
+    rowProps: {
+      ...L(i, u, C),
+      "aria-labelledby": Qt(e, n.key)
+    },
+    ...a
+  };
+}
+function fo(t, e, l) {
+  let { node: n, isVirtualized: o } = t, i = {
+    role: "row"
+  };
+  return o && !(je() && "expandedKeys" in e) && (i["aria-rowindex"] = n.index + 1), {
+    rowProps: i
+  };
+}
+function po(t, e, l) {
+  var n;
+  let { gridCellProps: o, isPressed: i } = qt(t, e, l), a = (n = t.node.column) === null || n === void 0 ? void 0 : n.key;
+  return a != null && e.collection.rowHeaderColumnKeys.has(a) && (o.role = "rowheader", o.id = Jt(e, t.node.parentKey, a)), {
+    gridCellProps: o,
+    isPressed: i
+  };
+}
+function mo(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function ho(t, e) {
+  let { key: l } = t;
+  const { checkboxProps: n } = mn(t, e);
+  return {
+    checkboxProps: {
+      ...n,
+      "aria-labelledby": `${n.id} ${Qt(e, l)}`
+    }
+  };
+}
+function bo(t) {
+  let { isEmpty: e, isSelectAll: l, selectionMode: n } = t.selectionManager;
+  return {
+    checkboxProps: {
+      "aria-label": Ke(mo(Me), "@react-aria/table").format(n === "single" ? "select" : "selectAll"),
+      isSelected: l,
+      isDisabled: n !== "multiple" || t.collection.size === 0 || t.collection.rows.length === 1 && t.collection.rows[0].type === "loader",
+      isIndeterminate: !e && !l,
+      onChange: () => t.selectionManager.toggleSelectAll()
+    }
+  };
+}
+function go(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function vo(t, e, l) {
+  let { column: n, triggerRef: o, isDisabled: i, onResizeStart: a, onResize: s, onResizeEnd: u, "aria-label": d } = t;
+  const c = Ke(go(Me), "@react-aria/table");
+  let r = lt(), p = e.resizingColumn === n.key, f = T(p), m = T(null), h = T(!1), y = e.tableState.isKeyboardNavigationDisabled, { direction: v } = Se(), { keyboardProps: $ } = Vn({
+    onKeyDown: (k) => {
+      y ? (k.key === "Escape" || k.key === "Enter" || k.key === " " || k.key === "Tab") && (k.preventDefault(), g(n)) : (k.continuePropagation(), k.key === "Enter" && b(n));
+    }
+  }), b = Ae((k) => {
+    f.current || (m.current = e.updateResizedColumns(k.key, e.getColumnWidth(k.key)), e.startResize(k.key), e.tableState.setKeyboardNavigationDisabled(!0), a?.(m.current)), f.current = !0;
+  }), C = Ae((k, S) => {
+    let I = e.updateResizedColumns(k.key, S);
+    s?.(I), m.current = I;
+  }), g = Ae((k) => {
+    f.current && (m.current == null && (m.current = e.updateResizedColumns(k.key, e.getColumnWidth(k.key))), e.endResize(), e.tableState.setKeyboardNavigationDisabled(!1), u?.(m.current), f.current = !1, o?.current && !h.current && _(o.current)), m.current = null;
+  });
+  const w = T(0), { moveProps: D } = eo({
+    onMoveStart() {
+      w.current = e.getColumnWidth(n.key), b(n);
+    },
+    onMove(k) {
+      let { deltaX: S, deltaY: I, pointerType: ie } = k;
+      v === "rtl" && (S *= -1), ie === "keyboard" && (I !== 0 && S === 0 && (S = I * -1), S *= 10), S !== 0 && (w.current += S, C(n, w.current));
+    },
+    onMoveEnd(k) {
+      let { pointerType: S } = k;
+      w.current = 0, (S === "mouse" || S === "touch" && h.current) && g(n);
+    }
+  });
+  let R = V((k) => {
+    var S;
+    y && ((S = D.onKeyDown) === null || S === void 0 || S.call(D, k));
+  }, [
+    y,
+    D
+  ]), P = Math.floor(e.getColumnMinWidth(n.key)), z = Math.floor(e.getColumnMaxWidth(n.key));
+  z === 1 / 0 && (z = Number.MAX_SAFE_INTEGER);
+  let N = Math.floor(e.getColumnWidth(n.key)), H = Wn();
+  H === "virtual" && typeof window < "u" && "ontouchstart" in window && (H = "touch");
+  let O = o?.current == null && (H === "keyboard" || H === "virtual") && !p ? c.format("resizerDescription") : void 0, F = nt(O), M = {
+    "aria-label": d,
+    "aria-orientation": "horizontal",
+    "aria-labelledby": `${r} ${Zt(e.tableState, n.key)}`,
+    "aria-valuetext": c.format("columnSize", {
+      value: N
+    }),
+    type: "range",
+    min: P,
+    max: z,
+    value: N,
+    ...F
+  };
+  const G = V(() => {
+    l.current && _(l.current);
+  }, [
+    l
+  ]);
+  let j = e.resizingColumn, le = T(null);
+  se(() => {
+    if (le.current !== j && j != null && j === n.key) {
+      h.current = document.activeElement === l.current, b(n);
+      let k = setTimeout(() => G(), 0), S = setTimeout(G, 400);
+      return () => {
+        clearTimeout(k), clearTimeout(S);
+      };
+    }
+    le.current = j;
+  }, [
+    j,
+    n,
+    G,
+    l,
+    b
+  ]);
+  let fe = (k) => {
+    let S = e.getColumnWidth(n.key), I = parseFloat(k.target.value);
+    I > S ? I = S + 10 : I = S - 10, C(n, I);
+  }, { pressProps: pe } = Ut({
+    preventFocusOnPress: !0,
+    onPressStart: (k) => {
+      if (!(k.ctrlKey || k.altKey || k.metaKey || k.shiftKey || k.pointerType === "keyboard")) {
+        if (k.pointerType === "virtual" && e.resizingColumn != null) {
+          g(n);
+          return;
+        }
+        G(), k.pointerType !== "virtual" && b(n);
+      }
+    },
+    onPress: (k) => {
+      (k.pointerType === "touch" && h.current || k.pointerType === "mouse") && e.resizingColumn != null && g(n);
+    }
+  }), { visuallyHiddenProps: Q } = Xe();
+  return {
+    resizerProps: L($, {
+      ...D,
+      onKeyDown: R
+    }, pe, {
+      style: {
+        touchAction: "none"
+      }
+    }),
+    inputProps: L(Q, {
+      id: r,
+      onBlur: () => {
+        g(n);
+      },
+      onChange: fe,
+      disabled: i
+    }, M),
+    isResizing: p
+  };
+}
+function Bl() {
+  return no();
+}
+function yo(t) {
+  return t != null && (!isNaN(t) || String(t).match(/^(\d+)(?=%$)/) !== null);
+}
+function $o(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 rt(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 Kl(t, e) {
+  return t != null ? rt(t, e) : Number.MAX_SAFE_INTEGER;
+}
+function Ml(t, e) {
+  return t != null ? rt(t, e) : 0;
+}
+function xo(t, e, l, n, o) {
+  let i = !1, a = e.map((s, u) => {
+    var d, c, r, p;
+    let f = l.get(s.key) != null ? (d = l.get(s.key)) !== null && d !== void 0 ? d : "1fr" : (p = (r = (c = s.width) !== null && c !== void 0 ? c : s.defaultWidth) !== null && r !== void 0 ? r : n?.(u)) !== null && p !== void 0 ? p : "1fr", m = !1, h = 0, y = 0, v = 0;
+    yo(f) ? (h = rt(f, t), m = !0) : (y = $o(f), y <= 0 && (m = !0));
+    var $, b;
+    let C = Ml((b = ($ = s.minWidth) !== null && $ !== void 0 ? $ : o?.(u)) !== null && b !== void 0 ? b : 0, t), g = Kl(s.maxWidth, t), w = Math.max(C, Math.min(h, g));
+    return m ? v = w : h > w && (m = !0, v = w), m || (i = !0), {
+      frozen: m,
+      baseSize: h,
+      hypotheticalMainSize: w,
+      min: C,
+      max: g,
+      flex: y,
+      targetMainSize: v,
+      violation: 0
+    };
+  });
+  for (; i; ) {
+    let s = 0, u = 0;
+    a.forEach((r) => {
+      r.frozen ? s += r.targetMainSize : (s += r.baseSize, u += r.flex);
+    });
+    let d = t - s;
+    d > 0 && a.forEach((r) => {
+      if (!r.frozen) {
+        let p = r.flex / u;
+        r.targetMainSize = r.baseSize + p * d;
+      }
+    });
+    let c = 0;
+    a.forEach((r) => {
+      if (r.violation = 0, !r.frozen) {
+        let { min: p, max: f, targetMainSize: m } = r;
+        r.targetMainSize = Math.max(p, Math.min(m, f)), r.violation = r.targetMainSize - m, c += r.violation;
+      }
+    }), i = !1, a.forEach((r) => {
+      c === 0 || Math.sign(c) === Math.sign(r.violation) ? r.frozen = !0 : r.frozen || (i = !0);
+    });
+  }
+  return Co(a);
+}
+function Co(t) {
+  let e = 0, l = 0, n = [];
+  return t.forEach(function(o) {
+    let i = o.targetMainSize, a = Math.round(i + e) - l;
+    e += i, l += a, n.push(a);
+  }), n;
+}
+class wo {
+  /** 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, a, s;
+      return [
+        l,
+        (s = (a = n.props.defaultWidth) !== null && a !== void 0 ? a : (o = (i = this).getDefaultWidth) === null || o === void 0 ? void 0 : o.call(i, n)) !== null && s !== void 0 ? s : "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, a = !0, s = /* @__PURE__ */ new Map();
+    return o = Math.max(this.getColumnMinWidth(n), Math.min(this.getColumnMaxWidth(n), Math.floor(o))), e.columns.forEach((u) => {
+      var d, c;
+      u.key === n ? (s.set(u.key, o), a = !1) : a ? s.set(u.key, (d = i.get(u.key)) !== null && d !== void 0 ? d : 0) : s.set(u.key, (c = u.props.width) !== null && c !== void 0 ? c : l.get(u.key));
+    }), s;
+  }
+  buildColumnWidths(e, l, n) {
+    return this.columnWidths = /* @__PURE__ */ new Map(), this.columnMinWidths = /* @__PURE__ */ new Map(), this.columnMaxWidths = /* @__PURE__ */ new Map(), xo(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, a) => {
+      let s = l.columns[a].key, u = l.columns[a];
+      this.columnWidths.set(s, i);
+      var d;
+      this.columnMinWidths.set(s, Ml((d = u.props.minWidth) !== null && d !== void 0 ? d : this.getDefaultMinWidth(u), e)), this.columnMaxWidths.set(s, Kl(u.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 Do(t, e) {
+  let { getDefaultWidth: l, getDefaultMinWidth: n, tableWidth: o = 0 } = t, [i, a] = X(null), s = K(() => new wo({
+    getDefaultWidth: l,
+    getDefaultMinWidth: n
+  }), [
+    l,
+    n
+  ]), [u, d] = K(() => s.splitColumnsIntoControlledAndUncontrolled(e.collection.columns), [
+    e.collection.columns,
+    s
+  ]), [c, r] = X(() => s.getInitialUncontrolledWidths(d)), [p, f] = X(e.collection.columns);
+  if (e.collection.columns !== p) {
+    if (e.collection.columns.length !== p.length || e.collection.columns.some((b, C) => b.key !== p[C].key)) {
+      let b = s.getInitialUncontrolledWidths(d);
+      r(b);
+    }
+    f(e.collection.columns);
+  }
+  let m = K(() => s.recombineColumns(e.collection.columns, c, d, u), [
+    e.collection.columns,
+    c,
+    d,
+    u,
+    s
+  ]), h = V((b) => {
+    a(b);
+  }, [
+    a
+  ]), y = V((b, C) => {
+    let g = s.resizeColumnWidth(e.collection, c, b, C), w = new Map(Array.from(d).map(([D]) => [
+      D,
+      g.get(D)
+    ]));
+    return w.set(b, C), r(w), g;
+  }, [
+    d,
+    r,
+    s,
+    e.collection,
+    c
+  ]), v = V(() => {
+    a(null);
+  }, [
+    a
+  ]), $ = K(() => s.buildColumnWidths(o, e.collection, m), [
+    o,
+    e.collection,
+    m,
+    s
+  ]);
+  return K(() => ({
+    resizingColumn: i,
+    updateResizedColumns: y,
+    startResize: h,
+    endResize: v,
+    getColumnWidth: (b) => s.getColumnWidth(b),
+    getColumnMinWidth: (b) => s.getColumnMinWidth(b),
+    getColumnMaxWidth: (b) => s.getColumnMaxWidth(b),
+    tableState: e,
+    columnWidths: $
+  }), [
+    s,
+    $,
+    i,
+    y,
+    h,
+    v,
+    e
+  ]);
+}
+function So(t) {
+  let { collection: e, focusMode: l } = t, n = t.UNSAFE_selectionState || Wt(t), o = K(() => t.disabledKeys ? new Set(t.disabledKeys) : /* @__PURE__ */ new Set(), [
+    t.disabledKeys
+  ]), i = n.setFocusedKey;
+  n.setFocusedKey = (u, d) => {
+    if (l === "cell" && u != null) {
+      let m = e.getItem(u);
+      if (m?.type === "item") {
+        var c, r;
+        let h = W(m, e);
+        var p, f;
+        d === "last" ? u = (p = (c = ae(h)) === null || c === void 0 ? void 0 : c.key) !== null && p !== void 0 ? p : null : u = (f = (r = re(h)) === null || r === void 0 ? void 0 : r.key) !== null && f !== void 0 ? f : null;
+      }
+    }
+    i(u, d);
+  };
+  let a = K(() => new yn(e, n), [
+    e,
+    n
+  ]);
+  const s = T(null);
+  return se(() => {
+    if (n.focusedKey != null && s.current && !e.getItem(n.focusedKey)) {
+      const u = s.current.getItem(n.focusedKey), d = u?.parentKey != null && (u.type === "cell" || u.type === "rowheader" || u.type === "column") ? s.current.getItem(u.parentKey) : u;
+      if (!d) {
+        n.setFocusedKey(null);
+        return;
+      }
+      const c = s.current.rows, r = e.rows, p = c.length - r.length;
+      let f = Math.min(p > 1 ? Math.max(d.index - p + 1, 0) : d.index, r.length - 1), m = null;
+      for (; f >= 0; ) {
+        if (!a.isDisabled(r[f].key) && r[f].type !== "headerrow") {
+          m = r[f];
+          break;
+        }
+        f < r.length - 1 ? f++ : (f > d.index && (f = d.index), f--);
+      }
+      if (m) {
+        const h = m.hasChildNodes ? [
+          ...W(m, e)
+        ] : [], y = m.hasChildNodes && d !== u && u && u.index < h.length ? h[u.index].key : m.key;
+        n.setFocusedKey(y);
+      } else n.setFocusedKey(null);
+    }
+    s.current = e;
+  }, [
+    e,
+    a,
+    n,
+    n.focusedKey
+  ]), {
+    collection: e,
+    disabledKeys: o,
+    isKeyboardNavigationDisabled: !1,
+    selectionManager: a
+  };
+}
+class ko {
+  *[Symbol.iterator]() {
+    yield* [
+      ...this.rows
+    ];
+  }
+  get size() {
+    return [
+      ...this.rows
+    ].length;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return l && (n = l.prevKey) !== null && n !== void 0 ? n : null;
+  }
+  getKeyAfter(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return l && (n = l.nextKey) !== null && n !== void 0 ? n : null;
+  }
+  getFirstKey() {
+    var e;
+    return (e = [
+      ...this.rows
+    ][0]) === null || e === void 0 ? void 0 : e.key;
+  }
+  getLastKey() {
+    var e;
+    let l = [
+      ...this.rows
+    ];
+    return (e = l[l.length - 1]) === null || e === void 0 ? void 0 : e.key;
+  }
+  getItem(e) {
+    var l;
+    return (l = this.keyMap.get(e)) !== null && l !== void 0 ? l : null;
+  }
+  at(e) {
+    const l = [
+      ...this.getKeys()
+    ];
+    return this.getItem(l[e]);
+  }
+  getChildren(e) {
+    let l = this.keyMap.get(e);
+    return l?.childNodes || [];
+  }
+  constructor(e) {
+    this.keyMap = /* @__PURE__ */ new Map(), this.keyMap = /* @__PURE__ */ new Map(), this.columnCount = e?.columnCount, this.rows = [];
+    let l = (r) => {
+      let p = this.keyMap.get(r.key);
+      e.visitNode && (r = e.visitNode(r)), this.keyMap.set(r.key, r);
+      let f = /* @__PURE__ */ new Set(), m = null, h = !1;
+      if (r.type === "item") {
+        var y;
+        for (let g of r.childNodes) if (((y = g.props) === null || y === void 0 ? void 0 : y.colSpan) !== void 0) {
+          h = !0;
+          break;
+        }
+      }
+      for (let g of r.childNodes) {
+        if (g.type === "cell" && h) {
+          var v, $;
+          g.colspan = (v = g.props) === null || v === void 0 ? void 0 : v.colSpan, g.colSpan = ($ = g.props) === null || $ === void 0 ? void 0 : $.colSpan;
+          var b, C;
+          g.colIndex = m ? ((b = m.colIndex) !== null && b !== void 0 ? b : m.index) + ((C = m.colSpan) !== null && C !== void 0 ? C : 1) : g.index;
+        }
+        g.type === "cell" && g.parentKey == null && (g.parentKey = r.key), f.add(g.key), m ? (m.nextKey = g.key, g.prevKey = m.key) : g.prevKey = null, l(g), m = g;
+      }
+      if (m && (m.nextKey = null), p)
+        for (let g of p.childNodes) f.has(g.key) || n(g);
+    }, n = (r) => {
+      this.keyMap.delete(r.key);
+      for (let p of r.childNodes) this.keyMap.get(p.key) === p && n(p);
+    }, o = null;
+    for (let [r, p] of e.items.entries()) {
+      var i, a, s, u, d, c;
+      let f = {
+        ...p,
+        level: (i = p.level) !== null && i !== void 0 ? i : 0,
+        key: (a = p.key) !== null && a !== void 0 ? a : "row-" + r,
+        type: (s = p.type) !== null && s !== void 0 ? s : "row",
+        value: (u = p.value) !== null && u !== void 0 ? u : null,
+        hasChildNodes: !0,
+        childNodes: [
+          ...p.childNodes
+        ],
+        rendered: p.rendered,
+        textValue: (d = p.textValue) !== null && d !== void 0 ? d : "",
+        index: (c = p.index) !== null && c !== void 0 ? c : r
+      };
+      o ? (o.nextKey = f.key, f.prevKey = o.key) : f.prevKey = null, this.rows.push(f), l(f), o = f;
+    }
+    o && (o.nextKey = null);
+  }
+}
+const Nl = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+let _e = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+for (; Nl === _e; ) _e = "row-header-column-" + Math.random().toString(36).slice(2);
+function Fl(t, e) {
+  if (e.length === 0) return [];
+  let l = [], n = /* @__PURE__ */ new Map();
+  for (let c of e) {
+    let r = c.parentKey, p = [
+      c
+    ];
+    for (; r; ) {
+      let f = t.get(r);
+      if (!f) break;
+      if (n.has(f)) {
+        var o, i;
+        (i = (o = f).colSpan) !== null && i !== void 0 || (o.colSpan = 0), f.colSpan++, f.colspan = f.colSpan;
+        let { column: m, index: h } = n.get(f);
+        if (h > p.length) break;
+        for (let y = h; y < p.length; y++) m.splice(y, 0, null);
+        for (let y = p.length; y < m.length; y++)
+          m[y] && n.has(m[y]) && (n.get(m[y]).index = y);
+      } else
+        f.colSpan = 1, f.colspan = 1, p.push(f), n.set(f, {
+          column: p,
+          index: p.length - 1
+        });
+      r = f.parentKey;
+    }
+    l.push(p), c.index = l.length - 1;
+  }
+  let a = Math.max(...l.map((c) => c.length)), s = Array(a).fill(0).map(() => []), u = 0;
+  for (let c of l) {
+    let r = a - 1;
+    for (let p of c) {
+      if (p) {
+        let f = s[r], m = f.reduce((h, y) => {
+          var v;
+          return h + ((v = y.colSpan) !== null && v !== void 0 ? v : 1);
+        }, 0);
+        if (m < u) {
+          let h = {
+            type: "placeholder",
+            key: "placeholder-" + p.key,
+            colspan: u - m,
+            colSpan: u - m,
+            index: m,
+            value: null,
+            rendered: null,
+            level: r,
+            hasChildNodes: !1,
+            childNodes: [],
+            textValue: ""
+          };
+          f.length > 0 && (f[f.length - 1].nextKey = h.key, h.prevKey = f[f.length - 1].key), f.push(h);
+        }
+        f.length > 0 && (f[f.length - 1].nextKey = p.key, p.prevKey = f[f.length - 1].key), p.level = r, p.colIndex = u, f.push(p);
+      }
+      r--;
+    }
+    u++;
+  }
+  let d = 0;
+  for (let c of s) {
+    let r = c.reduce((p, f) => {
+      var m;
+      return p + ((m = f.colSpan) !== null && m !== void 0 ? m : 1);
+    }, 0);
+    if (r < e.length) {
+      let p = {
+        type: "placeholder",
+        key: "placeholder-" + c[c.length - 1].key,
+        colSpan: e.length - r,
+        colspan: e.length - r,
+        index: r,
+        value: null,
+        rendered: null,
+        level: d,
+        hasChildNodes: !1,
+        childNodes: [],
+        textValue: "",
+        prevKey: c[c.length - 1].key
+      };
+      c.push(p);
+    }
+    d++;
+  }
+  return s.map((c, r) => ({
+    type: "headerrow",
+    key: "headerrow-" + r,
+    index: r,
+    value: null,
+    rendered: null,
+    level: 0,
+    hasChildNodes: !0,
+    childNodes: c,
+    textValue: ""
+  }));
+}
+class Eo extends ko {
+  *[Symbol.iterator]() {
+    yield* this.body.childNodes;
+  }
+  get size() {
+    return this._size;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return (n = l?.prevKey) !== null && n !== void 0 ? n : null;
+  }
+  getKeyAfter(e) {
+    let l = this.keyMap.get(e);
+    var n;
+    return (n = l?.nextKey) !== null && n !== void 0 ? n : null;
+  }
+  getFirstKey() {
+    var e, l;
+    return (l = (e = re(this.body.childNodes)) === null || e === void 0 ? void 0 : e.key) !== null && l !== void 0 ? l : null;
+  }
+  getLastKey() {
+    var e, l;
+    return (l = (e = ae(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 a = this.columns[i.index];
+        if (n.has(a.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, a = [];
+    if (n?.showSelectionCheckboxes) {
+      let r = {
+        type: "column",
+        key: Nl,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: n?.showDragButtons ? 1 : 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isSelectionCell: !0
+        }
+      };
+      a.unshift(r);
+    }
+    if (n?.showDragButtons) {
+      let r = {
+        type: "column",
+        key: _e,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isDragButtonCell: !0
+        }
+      };
+      a.unshift(r);
+    }
+    let s = [], u = /* @__PURE__ */ new Map(), d = (r) => {
+      switch (r.type) {
+        case "body":
+          i = r;
+          break;
+        case "column":
+          u.set(r.key, r), r.hasChildNodes || (a.push(r), r.props.isRowHeader && o.add(r.key));
+          break;
+        case "item":
+          s.push(r);
+          return;
+      }
+      for (let p of r.childNodes) d(p);
+    };
+    for (let r of e) d(r);
+    let c = Fl(u, a);
+    if (c.forEach((r, p) => s.splice(p, 0, r)), super({
+      columnCount: a.length,
+      items: s,
+      visitNode: (r) => (r.column = a[r.index], r)
+    }), this._size = 0, this.columns = a, this.rowHeaderColumnKeys = o, this.body = i, this.headerRows = c, this._size = [
+      ...i.childNodes
+    ].length, this.rowHeaderColumnKeys.size === 0) {
+      let r = this.columns.find((p) => {
+        var f, m;
+        return !(!((f = p.props) === null || f === void 0) && f.isDragButtonCell) && !(!((m = p.props) === null || m === void 0) && m.isSelectionCell);
+      });
+      r && this.rowHeaderColumnKeys.add(r.key);
+    }
+  }
+}
+const zo = {
+  ascending: "descending",
+  descending: "ascending"
+};
+function Ro(t) {
+  let [e, l] = X(!1), { selectionMode: n = "none", showSelectionCheckboxes: o, showDragButtons: i } = t, a = K(() => ({
+    showSelectionCheckboxes: o && n !== "none",
+    showDragButtons: i,
+    selectionMode: n,
+    columns: []
+  }), [
+    t.children,
+    o,
+    n,
+    i
+  ]), s = $n(t, V((r) => new Eo(r, null, a), [
+    a
+  ]), a), { disabledKeys: u, selectionManager: d } = So({
+    ...t,
+    collection: s,
+    disabledBehavior: t.disabledBehavior || "selection"
+  });
+  var c;
+  return {
+    collection: s,
+    disabledKeys: u,
+    selectionManager: d,
+    showSelectionCheckboxes: t.showSelectionCheckboxes || !1,
+    sortDescriptor: (c = t.sortDescriptor) !== null && c !== void 0 ? c : null,
+    isKeyboardNavigationDisabled: s.size === 0 || e,
+    setKeyboardNavigationDisabled: l,
+    sort(r, p) {
+      var f, m;
+      (m = t.onSortChange) === null || m === void 0 || m.call(t, {
+        column: r,
+        direction: p ?? (((f = t.sortDescriptor) === null || f === void 0 ? void 0 : f.column) === r ? zo[t.sortDescriptor.direction] : "ascending")
+      });
+    }
+  };
+}
+function Ao(t, e) {
+  let l = K(() => e ? t.collection.filter(e) : t.collection, [
+    t.collection,
+    e
+  ]), n = t.selectionManager.withCollection(l);
+  return {
+    ...t,
+    collection: l,
+    selectionManager: n
+  };
+}
+function Po(t) {
+  return t && t.__esModule ? t.default : t;
+}
+class To extends An {
+  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 a of this.getChildren(this.body.key)) {
+      let s = a.lastChildKey;
+      if (s != null) {
+        let u = this.getItem(s);
+        var o, i;
+        let d = ((o = u.colIndex) !== null && o !== void 0 ? o : u.index) + ((i = u.colSpan) !== null && i !== void 0 ? i : 1);
+        if (d !== this.columns.length && !n) throw new Error(`Cell count must match column count. Found ${d} cells and ${this.columns.length} columns.`);
+      }
+      this.rows.push(a);
+    }
+    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 = Fl(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 a = this.columns[i.index];
+      if (n.has(a.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 ut(-1), this.body = new dt(-2), this.columnsDirty = !0;
+  }
+}
+const at = /* @__PURE__ */ ue(null), Bo = /* @__PURE__ */ Ue(function(e, l) {
+  let n = J(l), o = T(null), i = T(null), [a, s] = X(0);
+  Et(() => {
+    let d = o.current;
+    for (; d && d !== n.current && !Kn(d); ) d = d.parentElement;
+    i.current = d;
+  }, [
+    n
+  ]), Bn({
+    ref: i,
+    box: "border-box",
+    onResize() {
+      var d, c;
+      s((c = (d = i.current) === null || d === void 0 ? void 0 : d.clientWidth) !== null && c !== void 0 ? c : 0);
+    }
+  }), Et(() => {
+    var d, c;
+    s((c = (d = i.current) === null || d === void 0 ? void 0 : d.clientWidth) !== null && c !== void 0 ? c : 0);
+  }, []);
+  let u = K(() => ({
+    tableRef: o,
+    scrollRef: i,
+    tableWidth: a,
+    useTableColumnResizeState: Do,
+    onResizeStart: e.onResizeStart,
+    onResize: e.onResize,
+    onResizeEnd: e.onResizeEnd
+  }), [
+    o,
+    a,
+    e.onResizeStart,
+    e.onResize,
+    e.onResizeEnd
+  ]);
+  return /* @__PURE__ */ E.createElement("div", {
+    ...te(e, {
+      global: !0
+    }),
+    ref: n,
+    className: e.className || "react-aria-ResizableTableContainer",
+    style: e.style,
+    onScroll: e.onScroll
+  }, /* @__PURE__ */ E.createElement(at.Provider, {
+    value: u
+  }, e.children));
+}), Ko = /* @__PURE__ */ ue(null), oe = /* @__PURE__ */ ue(null), st = /* @__PURE__ */ ue(null), Mo = /* @__PURE__ */ Ue(function(e, l) {
+  var n;
+  [e, l] = Ot(e, l, Ko);
+  let o = Wt(e), { selectionBehavior: i, selectionMode: a, disallowEmptySelection: s } = o, u = !!(!((n = e.dragAndDropHooks) === null || n === void 0) && n.useDraggableCollectionState), d = K(() => ({
+    selectionBehavior: a === "none" ? null : i,
+    selectionMode: a,
+    disallowEmptySelection: s,
+    allowsDragging: u
+  }), [
+    i,
+    a,
+    s,
+    u
+  ]), c = /* @__PURE__ */ E.createElement(Il.Provider, {
+    value: d
+  }, /* @__PURE__ */ E.createElement(Te, e));
+  return /* @__PURE__ */ E.createElement(zn, {
+    content: c,
+    createCollection: () => new To()
+  }, (r) => /* @__PURE__ */ E.createElement(No, {
+    props: e,
+    forwardedRef: l,
+    selectionState: o,
+    collection: r
+  }));
+});
+function No({ props: t, forwardedRef: e, selectionState: l, collection: n }) {
+  [t, e] = Ot(t, e, St);
+  let { shouldUseVirtualFocus: o, disallowTypeAhead: i, filter: a, ...s } = t, u = B(at);
+  e = J(K(() => xn(e, u?.tableRef), [
+    e,
+    u?.tableRef
+  ]));
+  let d = Ro({
+    ...s,
+    collection: n,
+    children: void 0,
+    UNSAFE_selectionState: l
+  }), c = Ao(d, a), { isVirtualized: r, layoutDelegate: p, dropTargetDelegate: f, CollectionRoot: m } = B(ee), { dragAndDropHooks: h } = t, { gridProps: y } = ao({
+    ...s,
+    layoutDelegate: p,
+    isVirtualized: r
+  }, c, e), v = c.selectionManager, $ = !!h?.useDraggableCollectionState, b = !!h?.useDroppableCollectionState, C = T($), g = T(b);
+  se(() => {
+    process.env.NODE_ENV !== "production" && (C.current !== $ && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), g.current !== b && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."));
+  }, [
+    $,
+    b
+  ]);
+  let w, D, R, P = !1, z = null, N = T(null);
+  if ($ && h) {
+    w = h.useDraggableCollectionState({
+      collection: c.collection,
+      selectionManager: v,
+      preview: h.renderDragPreview ? N : void 0
+    }), h.useDraggableCollection({}, w, e);
+    let k = h.DragPreview;
+    z = h.renderDragPreview ? /* @__PURE__ */ E.createElement(k, {
+      ref: N
+    }, h.renderDragPreview) : null;
+  }
+  if (b && h) {
+    D = h.useDroppableCollectionState({
+      collection: c.collection,
+      selectionManager: v
+    });
+    let k = new Gn({
+      collection: c.collection,
+      disabledKeys: v.disabledKeys,
+      disabledBehavior: v.disabledBehavior,
+      ref: e,
+      layoutDelegate: p
+    }), S = h.dropTargetDelegate || f || new h.ListDropTargetDelegate(n.rows, e);
+    R = h.useDroppableCollection({
+      keyboardDelegate: k,
+      dropTargetDelegate: S
+    }, D, e), P = D.isDropTarget({
+      type: "root"
+    });
+  }
+  let { focusProps: H, isFocused: O, isFocusVisible: F } = we(), M = de({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-Table",
+    values: {
+      isDropTarget: P,
+      isFocused: O,
+      isFocusVisible: F,
+      state: c
+    }
+  }), G = !!($ && !w?.isDisabled), j = M.style, le = null;
+  u && (le = u.useTableColumnResizeState({
+    tableWidth: u.tableWidth
+  }, c), r || (j = {
+    ...j,
+    tableLayout: "fixed",
+    width: "fit-content"
+  }));
+  let fe = U("table"), pe = te(t, {
+    global: !0
+  });
+  var Q;
+  return /* @__PURE__ */ E.createElement(Ge, {
+    values: [
+      [
+        oe,
+        c
+      ],
+      [
+        st,
+        le
+      ],
+      [
+        De,
+        {
+          dragAndDropHooks: h,
+          dragState: w,
+          dropState: D
+        }
+      ],
+      [
+        wn,
+        {
+          render: Oo
+        }
+      ],
+      [
+        St,
+        null
+      ],
+      [
+        gn,
+        null
+      ]
+    ]
+  }, /* @__PURE__ */ E.createElement(Ln, null, /* @__PURE__ */ E.createElement(fe, {
+    ...L(pe, M, y, H, R?.collectionProps),
+    style: j,
+    ref: e,
+    slot: t.slot || void 0,
+    onScroll: t.onScroll,
+    "data-allows-dragging": G || void 0,
+    "data-drop-target": P || void 0,
+    "data-focused": O || void 0,
+    "data-focus-visible": F || void 0
+  }, /* @__PURE__ */ E.createElement(En, null, /* @__PURE__ */ E.createElement(m, {
+    collection: c.collection,
+    scrollRef: (Q = u?.scrollRef) !== null && Q !== void 0 ? Q : e,
+    persistedKeys: Dn(v, h, D)
+  })))), z);
+}
+function U(t) {
+  let { isVirtualized: e } = B(ee);
+  return e ? "div" : t;
+}
+const Il = /* @__PURE__ */ ue(null);
+function Vl() {
+  return B(Il);
+}
+class ut extends Ye {
+}
+ut.type = "tableheader";
+const Fo = /* @__PURE__ */ tt(ut, (t, e) => {
+  let l = B(oe).collection, n = Rn({
+    items: l.headerRows,
+    children: V((d) => {
+      switch (d.type) {
+        case "headerrow":
+          return /* @__PURE__ */ E.createElement(Io, {
+            item: d
+          });
+        default:
+          throw new Error("Unsupported node type in TableHeader: " + d.type);
+      }
+    }, [])
+  }), o = U("thead"), { rowGroupProps: i } = Bl(), { hoverProps: a, isHovered: s } = Be({
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), u = de({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-TableHeader",
+    values: {
+      isHovered: s
+    }
+  });
+  return /* @__PURE__ */ E.createElement(o, {
+    ...L(te(t, {
+      global: !0
+    }), i, a),
+    ...u,
+    ref: e,
+    "data-hovered": s || void 0
+  }, n);
+}, (t) => /* @__PURE__ */ E.createElement(Te, {
+  dependencies: t.dependencies,
+  items: t.columns
+}, t.children));
+function Io({ item: t }) {
+  let e = T(null), l = B(oe), { isVirtualized: n, CollectionBranch: o } = B(ee), { rowProps: i } = fo({
+    node: t,
+    isVirtualized: n
+  }, l, e), { checkboxProps: a } = bo(l), s = U("tr");
+  return /* @__PURE__ */ E.createElement(s, {
+    ...i,
+    ref: e
+  }, /* @__PURE__ */ E.createElement(Ge, {
+    values: [
+      [
+        Vt,
+        {
+          slots: {
+            selection: a
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ E.createElement(o, {
+    collection: l.collection,
+    parent: t
+  })));
+}
+class Hl extends Ye {
+}
+Hl.type = "column";
+const Vo = /* @__PURE__ */ jt(Hl, (t, e, l) => {
+  var n, o;
+  let i = J(e), a = B(oe), { isVirtualized: s } = B(ee), { columnHeaderProps: u } = uo({
+    node: l,
+    isVirtualized: s
+  }, a, i), { isFocused: d, isFocusVisible: c, focusProps: r } = we(), p = B(st), f = !1;
+  if (p) f = p.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: m, isHovered: h } = Be({
+    isDisabled: !t.allowsSorting
+  }), y = de({
+    ...t,
+    id: void 0,
+    children: l.rendered,
+    defaultClassName: "react-aria-Column",
+    values: {
+      isHovered: h,
+      isFocused: d,
+      isFocusVisible: c,
+      allowsSorting: l.props.allowsSorting,
+      sortDirection: ((n = a.sortDescriptor) === null || n === void 0 ? void 0 : n.column) === l.key ? a.sortDescriptor.direction : void 0,
+      isResizing: f,
+      startResize: () => {
+        if (p)
+          p.startResize(l.key), a.setKeyboardNavigationDisabled(!0);
+        else throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+      },
+      sort: (C) => {
+        a.sort(l.key, C);
+      }
+    }
+  }), v = y.style;
+  p && (v = {
+    ...v,
+    width: p.getColumnWidth(l.key)
+  });
+  let $ = U("th"), b = te(t, {
+    global: !0
+  });
+  return delete b.id, /* @__PURE__ */ E.createElement($, {
+    ...L(b, u, r, m),
+    ...y,
+    style: v,
+    ref: i,
+    "data-hovered": h || void 0,
+    "data-focused": d || void 0,
+    "data-focus-visible": c || void 0,
+    "data-resizing": f || void 0,
+    "data-allows-sorting": l.props.allowsSorting || void 0,
+    "data-sort-direction": ((o = a.sortDescriptor) === null || o === void 0 ? void 0 : o.column) === l.key ? a.sortDescriptor.direction : void 0
+  }, /* @__PURE__ */ E.createElement(Ge, {
+    values: [
+      [
+        Wl,
+        {
+          column: l,
+          triggerRef: i
+        }
+      ],
+      [
+        ee,
+        Lt
+      ]
+    ]
+  }, y.children));
+}), Wl = /* @__PURE__ */ ue(null), Ho = /* @__PURE__ */ Ue(function(e, l) {
+  let n = B(st);
+  if (!n) throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+  let o = Ke(Po(Sn), "react-aria-components"), { onResizeStart: i, onResize: a, onResizeEnd: s } = B(at), { column: u, triggerRef: d } = B(Wl), c = T(null), { resizerProps: r, inputProps: p, isResizing: f } = vo({
+    column: u,
+    "aria-label": e["aria-label"] || o.format("tableResizer"),
+    onResizeStart: i,
+    onResize: a,
+    onResizeEnd: s,
+    triggerRef: d
+  }, n, c), { focusProps: m, isFocused: h, isFocusVisible: y } = we(), { hoverProps: v, isHovered: $ } = Be(e), b = n.getColumnMinWidth(u.key) >= n.getColumnWidth(u.key), C = n.getColumnMaxWidth(u.key) <= n.getColumnWidth(u.key), { direction: g } = Se(), w = "both";
+  b ? w = g === "rtl" ? "right" : "left" : C ? w = g === "rtl" ? "left" : "right" : w = "both";
+  let D = J(l), [R, P] = X("");
+  se(() => {
+    if (!D.current) return;
+    let M = window.getComputedStyle(D.current);
+    P(M.cursor);
+  }, [
+    D,
+    w
+  ]);
+  let z = de({
+    ...e,
+    defaultClassName: "react-aria-ColumnResizer",
+    values: {
+      isFocused: h,
+      isFocusVisible: y,
+      isResizing: f,
+      isHovered: $,
+      resizableDirection: w
+    }
+  }), [N, H] = X(!1), O = (M) => {
+    M.pointerType === "mouse" && H(!0);
+  };
+  !f && N && H(!1);
+  let F = te(e, {
+    global: !0
+  });
+  return /* @__PURE__ */ E.createElement("div", {
+    ref: D,
+    role: "presentation",
+    ...L(F, z, r, {
+      onPointerDown: O
+    }, v),
+    "data-hovered": $ || void 0,
+    "data-focused": h || void 0,
+    "data-focus-visible": y || void 0,
+    "data-resizing": f || void 0,
+    "data-resizable-direction": w
+  }, z.children, /* @__PURE__ */ E.createElement("input", {
+    ref: c,
+    ...L(p, m)
+  }), f && N && /* @__PURE__ */ Mn.createPortal(/* @__PURE__ */ E.createElement("div", {
+    style: {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      bottom: 0,
+      right: 0,
+      cursor: R
+    }
+  }), document.body));
+});
+class dt extends Pn {
+}
+dt.type = "tablebody";
+const Wo = /* @__PURE__ */ tt(dt, (t, e) => {
+  let l = B(oe), { isVirtualized: n } = B(ee), o = l.collection, { CollectionBranch: i } = B(ee), { dragAndDropHooks: a, dropState: s } = B(De), u = !!a?.useDroppableCollectionState && !s?.isDisabled;
+  var d;
+  let c = u && !!s && ((d = s.isDropTarget({
+    type: "root"
+  })) !== null && d !== void 0 ? d : !1), r = o.size === 0, p = {
+    isDropTarget: c,
+    isEmpty: r
+  }, f = de({
+    ...t,
+    id: void 0,
+    children: void 0,
+    defaultClassName: "react-aria-TableBody",
+    values: p
+  }), m, h = U("tr"), y = U("td"), v = o.columnCount;
+  if (r && t.renderEmptyState && l) {
+    let g = {}, w = {}, D = {};
+    n ? (w["aria-colspan"] = v, D = {
+      display: "contents"
+    }) : w.colSpan = v, m = /* @__PURE__ */ E.createElement(h, {
+      role: "row",
+      ...g,
+      style: D
+    }, /* @__PURE__ */ E.createElement(y, {
+      role: "rowheader",
+      ...w,
+      style: D
+    }, t.renderEmptyState(p)));
+  }
+  let { rowGroupProps: $ } = Bl(), b = U("tbody"), C = te(t, {
+    global: !0
+  });
+  return /* @__PURE__ */ E.createElement(b, {
+    ...L(C, f, $),
+    ref: e,
+    "data-empty": r || void 0
+  }, u && /* @__PURE__ */ E.createElement(Go, null), /* @__PURE__ */ E.createElement(i, {
+    collection: o,
+    parent: o.body,
+    renderDropIndicator: Cn(a, s)
+  }), m);
+});
+class Ll extends Ye {
+  filter(e, l, n) {
+    let o = e.getChildren(this.key);
+    for (let i of o) if (n(i.textValue, i)) {
+      let a = this.clone();
+      return l.addDescendants(a, e), a;
+    }
+    return null;
+  }
+}
+Ll.type = "item";
+const Tt = /* @__PURE__ */ tt(Ll, (t, e, l) => {
+  let n = J(e), o = B(oe), { dragAndDropHooks: i, dragState: a, dropState: s } = B(De), { isVirtualized: u, CollectionBranch: d } = B(ee), { rowProps: c, ...r } = co({
+    node: l,
+    shouldSelectOnPressUp: !!a,
+    isVirtualized: u
+  }, o, n), { isFocused: p, isFocusVisible: f, focusProps: m } = we(), { isFocusVisible: h, focusProps: y } = we({
+    within: !0
+  }), { hoverProps: v, isHovered: $ } = Be({
+    isDisabled: !r.allowsSelection && !r.hasAction,
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), { checkboxProps: b } = ho({
+    key: l.key
+  }, o), C;
+  a && i && (C = i.useDraggableItem({
+    key: l.key,
+    hasDragButton: !0
+  }, a));
+  let g, w = T(null), { visuallyHiddenProps: D } = Xe();
+  s && i && (g = i.useDropIndicator({
+    target: {
+      type: "item",
+      key: l.key,
+      dropPosition: "on"
+    }
+  }, s, w));
+  let R = T(null);
+  se(() => {
+    a && !R.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 P = a && a.isDragging(l.key), { children: z, ...N } = t, H = de({
+    ...N,
+    id: void 0,
+    defaultClassName: "react-aria-Row",
+    values: {
+      ...r,
+      isHovered: $,
+      isFocused: p,
+      isFocusVisible: f,
+      selectionMode: o.selectionManager.selectionMode,
+      selectionBehavior: o.selectionManager.selectionBehavior,
+      isDragging: P,
+      isDropTarget: g?.isDropTarget,
+      isFocusVisibleWithin: h,
+      id: l.key
+    }
+  }), O = U("tr"), F = U("td"), M = te(t, {
+    global: !0
+  });
+  return delete M.id, delete M.onClick, /* @__PURE__ */ E.createElement(E.Fragment, null, g && !g.isHidden && /* @__PURE__ */ E.createElement(O, {
+    role: "row",
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ E.createElement(F, {
+    role: "gridcell",
+    colSpan: o.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ E.createElement("div", {
+    role: "button",
+    ...D,
+    ...g.dropIndicatorProps,
+    ref: w
+  }))), /* @__PURE__ */ E.createElement(O, {
+    ...L(M, H, c, m, v, C?.dragProps, y),
+    ref: n,
+    "data-disabled": r.isDisabled || void 0,
+    "data-selected": r.isSelected || void 0,
+    "data-hovered": $ || void 0,
+    "data-focused": r.isFocused || void 0,
+    "data-focus-visible": f || void 0,
+    "data-pressed": r.isPressed || void 0,
+    "data-dragging": P || void 0,
+    "data-drop-target": g?.isDropTarget || void 0,
+    "data-selection-mode": o.selectionManager.selectionMode === "none" ? void 0 : o.selectionManager.selectionMode,
+    "data-focus-visible-within": h || void 0
+  }, /* @__PURE__ */ E.createElement(Ge, {
+    values: [
+      [
+        Vt,
+        {
+          slots: {
+            [kt]: {},
+            selection: b
+          }
+        }
+      ],
+      [
+        It,
+        {
+          slots: {
+            [kt]: {},
+            drag: {
+              ...C?.dragButtonProps,
+              ref: R,
+              style: {
+                pointerEvents: "none"
+              }
+            }
+          }
+        }
+      ],
+      [
+        kn,
+        {
+          isSelected: r.isSelected
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ E.createElement(d, {
+    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__ */ E.createElement(Te, {
+    dependencies: e,
+    items: t.columns,
+    idScope: t.id
+  }, t.children);
+});
+class Ol extends Ye {
+}
+Ol.type = "cell";
+const Lo = /* @__PURE__ */ jt(Ol, (t, e, l) => {
+  let n = J(e), o = B(oe), { dragState: i } = B(De), { isVirtualized: a } = B(ee);
+  l.column = o.collection.columns[l.index];
+  let { gridCellProps: s, isPressed: u } = po({
+    node: l,
+    shouldSelectOnPressUp: !!i,
+    isVirtualized: a
+  }, o, n), { isFocused: d, isFocusVisible: c, focusProps: r } = we(), { hoverProps: p, isHovered: f } = Be({}), m = de({
+    ...t,
+    id: void 0,
+    defaultClassName: "react-aria-Cell",
+    values: {
+      isFocused: d,
+      isFocusVisible: c,
+      isPressed: u,
+      isHovered: f,
+      id: l.key
+    }
+  }), h = U("td"), y = te(t, {
+    global: !0
+  });
+  return delete y.id, /* @__PURE__ */ E.createElement(h, {
+    ...L(y, m, s, r, p),
+    ref: n,
+    "data-focused": d || void 0,
+    "data-focus-visible": c || void 0,
+    "data-pressed": u || void 0
+  }, /* @__PURE__ */ E.createElement(ee.Provider, {
+    value: Lt
+  }, m.children));
+});
+function Oo(t, e) {
+  e = J(e);
+  let { dragAndDropHooks: l, dropState: n } = B(De), o = T(null), { dropIndicatorProps: i, isHidden: a, isDropTarget: s } = l.useDropIndicator(t, n, o);
+  return a ? null : /* @__PURE__ */ E.createElement(Uo, {
+    ...t,
+    dropIndicatorProps: i,
+    isDropTarget: s,
+    buttonRef: o,
+    ref: e
+  });
+}
+function jo(t, e) {
+  let { dropIndicatorProps: l, isDropTarget: n, buttonRef: o, ...i } = t, a = B(oe), { visuallyHiddenProps: s } = Xe(), u = de({
+    ...i,
+    defaultClassName: "react-aria-DropIndicator",
+    values: {
+      isDropTarget: n
+    }
+  }), d = U("tr"), c = U("td");
+  return /* @__PURE__ */ E.createElement(d, {
+    ...te(t, {
+      global: !0
+    }),
+    ...u,
+    role: "row",
+    ref: e,
+    "data-drop-target": n || void 0
+  }, /* @__PURE__ */ E.createElement(c, {
+    role: "gridcell",
+    colSpan: a.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ E.createElement("div", {
+    ...s,
+    role: "button",
+    ...l,
+    ref: o
+  }), u.children));
+}
+const Uo = /* @__PURE__ */ Ue(jo);
+function Go() {
+  let t = B(oe), { dragAndDropHooks: e, dropState: l } = B(De), n = T(null), { dropIndicatorProps: o } = e.useDropIndicator({
+    target: {
+      type: "root"
+    }
+  }, l, n), i = l.isDropTarget({
+    type: "root"
+  }), { visuallyHiddenProps: a } = Xe(), s = U("tr"), u = U("td");
+  return !i && o["aria-hidden"] ? null : /* @__PURE__ */ E.createElement(s, {
+    role: "row",
+    "aria-hidden": o["aria-hidden"],
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ E.createElement(u, {
+    role: "gridcell",
+    colSpan: t.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ E.createElement("div", {
+    role: "button",
+    ...a,
+    ...o,
+    ref: n
+  })));
+}
+const { withProvider: Yo, withContext: q } = /* @__PURE__ */ Jl({
+  key: "dataTable"
+}), Xo = /* @__PURE__ */ Yo("div", "root"), qo = /* @__PURE__ */ q("table", "table"), Zo = /* @__PURE__ */ q("tr", "header"), Jo = /* @__PURE__ */ q("th", "column"), Qo = /* @__PURE__ */ q("tbody", "body"), Bt = /* @__PURE__ */ q("tr", "row"), _o = /* @__PURE__ */ q("td", "cell"), ei = /* @__PURE__ */ q("footer", "footer"), ti = /* @__PURE__ */ q("td", "selectionCell"), jl = /* @__PURE__ */ q("button", "expandButton"), li = /* @__PURE__ */ q("span", "nestedIcon"), ni = /* @__PURE__ */ q("span", "headerSortIcon"), oi = /* @__PURE__ */ q("div", "columnResizer"), qe = /* @__PURE__ */ ue(null);
+qe.displayName = "DataTable.Context";
+const ct = /* @__PURE__ */ ue(null);
+ct.displayName = "CustomSettings.Context";
+const ce = () => {
+  const t = B(
+    qe
+  );
+  if (!t)
+    throw new Error("DataTable components must be used within DataTable.Root");
+  return t;
+}, ii = () => {
+  const t = B(ct);
+  if (!t)
+    throw new Error(
+      "CustomSettings components must be used within CustomSettings.Root"
+    );
+  return t;
+};
+function Ul(t, e, l, n) {
+  if (!e) return t;
+  const o = e.toLowerCase();
+  return t.map((i) => {
+    const a = l.some((s) => {
+      const u = s.accessor(i);
+      return typeof u == "string" && u.toLowerCase().includes(o);
+    });
+    if (n && i[n]) {
+      let s = i[n];
+      if (Array.isArray(i[n])) {
+        if (s = Ul(
+          i[n],
+          e,
+          l,
+          n
+        ), a || s && Array.isArray(s) && s.length > 0)
+          return { ...i, [n]: s };
+      } else if (a)
+        return { ...i, [n]: s };
+      return null;
+    } else
+      return a ? i : null;
+  }).filter(Boolean);
+}
+function Gl(t, e, l, n, o) {
+  const i = [], a = [];
+  t.forEach((d) => {
+    o?.has(d.id) ? i.push(d) : a.push(d);
+  });
+  let s = a;
+  if (e) {
+    const d = l.find((c) => c.id === e.column);
+    d && (s = [...a].sort((c, r) => {
+      const p = d.accessor(c), f = d.accessor(r);
+      if (p == null && f == null) return 0;
+      if (p == null) return 1;
+      if (f == null) return -1;
+      let m = p, h = f;
+      return typeof p == "number" && typeof f == "number" ? (m = p, h = f) : (m = String(p).toLowerCase(), h = String(f).toLowerCase()), m < h ? e.direction === "ascending" ? -1 : 1 : m > h ? e.direction === "ascending" ? 1 : -1 : 0;
+    }));
+  }
+  return [...i, ...s].map((d) => !n || !d[n] ? d : {
+    ...d,
+    [n]: Array.isArray(d[n]) ? Gl(
+      d[n],
+      e,
+      l,
+      n,
+      o
+    ) : d[n]
+  });
+}
+function Yl(t, e) {
+  return e ? t.some(
+    (l) => l[e] && (Array.isArray(l[e]) ? l[e].length > 0 : !0) || Array.isArray(l[e]) && Yl(l[e], e)
+  ) : !1;
+}
+const ft = function(e) {
+  const {
+    ref: l,
+    columns: n = [],
+    rows: o = [],
+    visibleColumns: i,
+    search: a,
+    sortDescriptor: s,
+    defaultSortDescriptor: u,
+    onSortChange: d,
+    selectedKeys: c,
+    defaultSelectedKeys: r,
+    onSelectionChange: p,
+    selectionMode: f = "none",
+    disallowEmptySelection: m = !1,
+    allowsSorting: h = !1,
+    maxHeight: y,
+    isTruncated: v = !1,
+    density: $ = "default",
+    nestedKey: b,
+    onRowClick: C,
+    onDetailsClick: g,
+    disabledKeys: w,
+    onRowAction: D,
+    isResizable: R,
+    pinnedRows: P,
+    defaultPinnedRows: z,
+    onPinToggle: N,
+    onColumnsChange: H,
+    onSettingsChange: O,
+    customSettings: F,
+    children: M,
+    ...G
+  } = e, j = T(null), le = J(Pe(j, l)), [fe, pe] = X(u), [Q, k] = X({}), [S, I] = X(
+    () => z || /* @__PURE__ */ new Set()
+  ), ie = s ?? fe, Ne = P ?? S, ge = K(() => {
+    if (!i)
+      return n;
+    const Y = new Map(n.map((Z) => [Z.id, Z]));
+    return i.map((Z) => Y.get(Z)).filter((Z) => Z !== void 0);
+  }, [n, i]), Fe = K(
+    () => a ? Ul(o, a, ge, b) : o,
+    [o, a, ge, b]
+  ), Ze = K(
+    () => Gl(
+      Fe,
+      ie,
+      ge,
+      b,
+      Ne
+    ),
+    [Fe, ie, ge, b, Ne]
+  ), vt = Yl(Ze, b), yt = f !== "none", $t = V(
+    (Y) => k((Z) => ({ ...Z, [Y]: !Z[Y] })),
+    []
+  ), xt = V(
+    (Y) => {
+      N ? N(Y) : I((Z) => {
+        const Ie = new Set(Z);
+        return Ie.has(Y) ? Ie.delete(Y) : Ie.add(Y), Ie;
+      });
+    },
+    [N]
+  ), Ct = V(
+    (Y) => {
+      d ? d(Y) : pe(Y);
+    },
+    [d]
+  ), ql = K(
+    () => ({
+      columns: n,
+      rows: o,
+      visibleColumns: i,
+      search: a,
+      sortDescriptor: ie,
+      selectedKeys: c,
+      defaultSelectedKeys: r,
+      expanded: Q,
+      allowsSorting: h,
+      selectionMode: f,
+      disallowEmptySelection: m,
+      maxHeight: y,
+      isTruncated: v,
+      density: $,
+      nestedKey: b,
+      onSortChange: Ct,
+      onSelectionChange: p,
+      onRowClick: C,
+      onDetailsClick: g,
+      toggleExpand: $t,
+      activeColumns: ge,
+      filteredRows: Fe,
+      sortedRows: Ze,
+      showExpandColumn: vt,
+      showSelectionColumn: yt,
+      isResizable: R,
+      disabledKeys: w,
+      onRowAction: D,
+      pinnedRows: Ne,
+      onPinToggle: N,
+      togglePin: xt,
+      onColumnsChange: H,
+      onSettingsChange: O
+    }),
+    [
+      n,
+      o,
+      i,
+      a,
+      ie,
+      c,
+      r,
+      Q,
+      h,
+      f,
+      m,
+      y,
+      v,
+      $,
+      b,
+      Ct,
+      p,
+      C,
+      g,
+      $t,
+      ge,
+      Fe,
+      Ze,
+      vt,
+      yt,
+      R,
+      w,
+      D,
+      Ne,
+      N,
+      xt,
+      H,
+      O
+    ]
+  ), Zl = K(
+    () => ({
+      customSettings: F
+    }),
+    [F]
+  );
+  return /* @__PURE__ */ x(
+    Xo,
+    {
+      ref: le,
+      truncated: v,
+      density: $,
+      maxH: y,
+      ...G,
+      asChild: !0,
+      children: /* @__PURE__ */ x(Bo, { children: /* @__PURE__ */ x(
+        qe.Provider,
+        {
+          value: ql,
+          children: /* @__PURE__ */ x(ct.Provider, { value: Zl, children: M })
+        }
+      ) })
+    }
+  );
+};
+ft.displayName = "DataTable.Root";
+const pt = function({
+  ref: e,
+  children: l,
+  ...n
+}) {
+  const o = T(null), i = J(Pe(o, e)), {
+    sortDescriptor: a,
+    onSortChange: s,
+    selectionMode: u,
+    onSelectionChange: d,
+    selectedKeys: c,
+    defaultSelectedKeys: r,
+    disallowEmptySelection: p,
+    disabledKeys: f
+  } = ce(), [m, h] = ke(n), y = a ? {
+    column: a.column,
+    direction: a.direction
+  } : void 0;
+  return /* @__PURE__ */ x(qo, { ...m, asChild: !0, children: /* @__PURE__ */ x(
+    Mo,
+    {
+      ref: i,
+      sortDescriptor: y,
+      onSortChange: ($) => {
+        $ && s && s({
+          column: String($.column),
+          direction: $.direction
+        });
+      },
+      selectedKeys: c,
+      defaultSelectedKeys: r,
+      onSelectionChange: d,
+      selectionMode: u,
+      disallowEmptySelection: p,
+      disabledKeys: f,
+      disabledBehavior: "all",
+      ...h,
+      children: l
+    }
+  ) });
+};
+pt.displayName = "DataTable.Table";
+const ri = {
+  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",
+  textPreviews: "Text previews",
+  textPreviewsAriaLabel: "Text previews section",
+  textVisibility: "Text visibility",
+  textVisibilityAriaLabel: "Text visibility section",
+  visibleColumns: "Visible columns",
+  visibleColumnsAria: "Visible columns list",
+  visibleColumnsList: "Visible columns"
+}, ai = {
+  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",
+  textPreviews: "Textvorschau",
+  textPreviewsAriaLabel: "Abschnitt Textvorschau",
+  textVisibility: "Textsichtbarkeit",
+  textVisibilityAriaLabel: "Abschnitt Textsichtbarkeit",
+  visibleColumns: "Sichtbare Spalten",
+  visibleColumnsAria: "Sichtbare Spaltenliste",
+  visibleColumnsList: "Sichtbare Spalten"
+}, si = {
+  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",
+  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"
+}, ui = {
+  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",
+  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"
+}, di = {
+  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",
+  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"
+}, be = {
+  en: /* @__PURE__ */ Ee(ri),
+  de: /* @__PURE__ */ Ee(ai),
+  es: /* @__PURE__ */ Ee(si),
+  "fr-FR": /* @__PURE__ */ Ee(ui),
+  "pt-BR": /* @__PURE__ */ Ee(di)
+}, Ce = ({
+  children: t,
+  ref: e,
+  column: l,
+  isInternalColumn: n,
+  width: o,
+  minWidth: i,
+  maxWidth: a,
+  ...s
+}) => {
+  const u = he(be), { sortDescriptor: d, isResizable: c } = ce(), r = d?.column === l?.id, p = l?.isResizable !== void 0 ? l?.isResizable : c, [f, m] = ke(s);
+  return /* @__PURE__ */ x(Jo, { ...f, asChild: !0, children: /* @__PURE__ */ x(
+    Vo,
+    {
+      width: o,
+      minWidth: i,
+      maxWidth: a,
+      ref: e,
+      ...m,
+      children: (h) => {
+        const { allowsSorting: y } = h;
+        return n ? typeof t == "function" ? t(h) : t : /* @__PURE__ */ A(
+          _n,
+          {
+            tabIndex: p || y ? -1 : 0,
+            className: "nimbus-data-table__column-container",
+            children: [
+              /* @__PURE__ */ x(
+                Nt,
+                {
+                  orientation: "vertical",
+                  className: "data-table-column-divider"
+                }
+              ),
+              typeof t == "function" ? t(h) : t,
+              y && /* @__PURE__ */ x(
+                ni,
+                {
+                  "aria-hidden": "true",
+                  "data-sort-active": r,
+                  "data-sort-direction": r ? d?.direction : "none",
+                  children: /* @__PURE__ */ x(Ql, {})
+                }
+              ),
+              p && /* @__PURE__ */ x(Ho, { "aria-label": u.format("resizeColumn"), children: ({ isResizing: v, isFocused: $, isHovered: b }) => /* @__PURE__ */ x(
+                oi,
+                {
+                  "data-resizing": v,
+                  "data-focused": $,
+                  "data-hovered": b
+                }
+              ) })
+            ]
+          }
+        );
+      }
+    }
+  ) });
+};
+Ce.displayName = "DataTable.Column";
+const mt = ({
+  ref: t,
+  ...e
+}) => {
+  const l = he(be), { activeColumns: n, allowsSorting: o, maxHeight: i, showExpandColumn: a } = ce(), { selectionBehavior: s, selectionMode: u } = Vl(), [d, c] = ke(e);
+  return /* @__PURE__ */ x(Zo, { ...d, asChild: !0, children: /* @__PURE__ */ A(
+    Fo,
+    {
+      ref: t,
+      className: "data-table-header",
+      ...i && { "data-sticky": !0 },
+      columns: n,
+      ...c,
+      children: [
+        s === "toggle" && /* @__PURE__ */ x(
+          Ce,
+          {
+            id: "selection",
+            className: "selection-column-header",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            children: u === "multiple" && /* @__PURE__ */ x(Yt, { slot: "selection" })
+          }
+        ),
+        a && /* @__PURE__ */ x(
+          Ce,
+          {
+            className: "expand-column-header",
+            maxWidth: s === "toggle" ? 24 : 72,
+            minWidth: s === "toggle" ? 24 : 72,
+            allowsSorting: !1,
+            "aria-label": l.format("expandRows"),
+            isInternalColumn: !0,
+            children: /* @__PURE__ */ x(At, { children: l.format("expandRows") })
+          }
+        ),
+        /* @__PURE__ */ x(Te, { items: n, children: (r) => /* @__PURE__ */ A(
+          Ce,
+          {
+            allowsSorting: (
+              // use column.isSortable if defined, and fallback to allowsSorting if not
+              r.isSortable !== void 0 ? r.isSortable : o
+            ),
+            isRowHeader: !0,
+            width: r.width,
+            defaultWidth: r.defaultWidth,
+            minWidth: r.minWidth ?? 150,
+            maxWidth: r.maxWidth,
+            column: r,
+            children: [
+              /* @__PURE__ */ x("span", { "data-multiline-header": !0, children: r.header }),
+              r.headerIcon && /* @__PURE__ */ x(ne, { as: "span", ml: "200", children: r.headerIcon })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ x(
+          Ce,
+          {
+            className: "pin-rows-column-header",
+            id: "pin-rows",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            "aria-label": l.format("pinRows"),
+            children: /* @__PURE__ */ x(At, { children: l.format("pinRows") })
+          }
+        )
+      ]
+    }
+  ) });
+};
+mt.displayName = "DataTable.Header";
+const me = ({
+  ref: t,
+  children: e,
+  isDisabled: l,
+  ...n
+}) => {
+  const [o, i] = ke(n);
+  return /* @__PURE__ */ x(_o, { asChild: !0, ...o, children: /* @__PURE__ */ x(Lo, { ref: t, ...i, children: (a) => /* @__PURE__ */ x(It.Provider, { value: { isDisabled: l }, children: typeof e == "function" ? e(a) : e }) }) });
+};
+me.displayName = "DataTable.Cell";
+function et(t) {
+  return t.target?.closest(
+    'button, input, [role="button"], [role="checkbox"], [slot="selection"], [data-slot="selection"]'
+  );
+}
+function ci(t) {
+  return t.target?.closest(
+    '[slot="selection"], [data-slot="selection"], [role="checkbox"]'
+  );
+}
+function Kt(t) {
+  const e = et(t), l = ci(t);
+  (!e || e && !l) && t.stopPropagation();
+}
+const ht = ({
+  row: t,
+  ref: e,
+  ...l
+}) => {
+  const n = he(be), {
+    activeColumns: o,
+    search: i,
+    expanded: a,
+    toggleExpand: s,
+    nestedKey: u,
+    disabledKeys: d,
+    showExpandColumn: c,
+    showSelectionColumn: r,
+    isTruncated: p,
+    onRowClick: f,
+    onRowAction: m,
+    pinnedRows: h,
+    togglePin: y,
+    sortedRows: v
+  } = ce(), [$, b] = ke(l), g = ((S) => d ? d === "all" || t.isDisabled ? !0 : d.has(S) : !1)(t.id), w = T(null), D = V(
+    (S) => {
+      if (!f) return;
+      const I = et(S), ie = window.getSelection()?.toString() !== void 0 && window.getSelection().toString().length > 0;
+      !I && !ie && (w.current && window.clearTimeout(w.current), w.current = window.setTimeout(() => {
+        g ? m && m(t, "click") : f(t), w.current = null;
+      }, 300));
+    },
+    [f, m, t, g]
+  ), R = V((S) => {
+    et(S) || w.current && (window.clearTimeout(w.current), w.current = null);
+  }, []), P = T({
+    count: 0,
+    node: void 0
+  }), z = V(
+    (S) => {
+      P.current.count += 1, P.current.count === 1 && S && (P.current.node = S, S.addEventListener(
+        // Use pointerdown event in order to capture event before it bubbles to react-aria's onPress handler
+        "pointerdown",
+        Kt,
+        {
+          capture: !0
+        }
+      ), S.addEventListener("mouseup", D, { capture: !0 }), S.addEventListener("dblclick", R, {
+        capture: !0
+      }));
+    },
+    [D, R]
+  );
+  se(() => () => {
+    w.current && (window.clearTimeout(w.current), w.current = null), P.current.count >= 1 && P.current.node && (P.current.node.removeEventListener(
+      "pointerdown",
+      Kt
+    ), P.current.node.removeEventListener("mouseup", D), P.current.node.removeEventListener(
+      "dblclick",
+      R
+    ));
+  }, [D, R]);
+  const N = Pe(e, z), { selectionBehavior: H } = Vl(), O = u && t[u] && (Array.isArray(t[u]) ? t[u].length > 0 : !0), F = a[t.id], M = h.has(t.id), G = v.filter((S) => h.has(S.id)).map((S) => S.id), j = M ? G.indexOf(t.id) : -1, le = j === 0, fe = j === G.length - 1, pe = G.length === 1 && M, Q = () => M ? pe ? "data-table-row-pinned-single" : le ? "data-table-row-pinned-first" : fe ? "data-table-row-pinned-last" : "" : "", k = (S) => i && typeof S == "string" ? /* @__PURE__ */ x(Qn, { query: i, ignoreCase: !0, matchAll: !0, children: S }) : S;
+  return /* @__PURE__ */ A(ze, { children: [
+    /* @__PURE__ */ x(Bt, { asChild: !0, ...$, children: /* @__PURE__ */ A(
+      Tt,
+      {
+        isDisabled: g,
+        columns: o,
+        ref: N,
+        id: t.id,
+        className: `data-table-row ${g ? "data-table-row-disabled" : ""} ${M ? `data-table-row-pinned ${Q()}` : ""}`,
+        ...b,
+        dependencies: [F, i, p],
+        children: [
+          H === "toggle" && /* @__PURE__ */ x(
+            me,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "selection",
+              isDisabled: g,
+              children: /* @__PURE__ */ x(
+                ne,
+                {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  w: "100%",
+                  h: "100%",
+                  children: /* @__PURE__ */ x(
+                    Yt,
+                    {
+                      name: "select-row",
+                      slot: "selection",
+                      "aria-label": n.format("selectRow")
+                    }
+                  )
+                }
+              )
+            }
+          ),
+          c && /* @__PURE__ */ x(
+            me,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "expand",
+              isDisabled: g,
+              children: O ? /* @__PURE__ */ x(
+                jl,
+                {
+                  w: "100%",
+                  h: "100%",
+                  cursor: "pointer",
+                  "aria-label": F ? "Collapse" : "Expand",
+                  onClick: (S) => {
+                    S.stopPropagation(), s(t.id);
+                  },
+                  children: F ? /* @__PURE__ */ x(_l, {}) : /* @__PURE__ */ x(en, {})
+                }
+              ) : null
+            }
+          ),
+          /* @__PURE__ */ x(Te, { items: o, children: (S) => {
+            const I = S.accessor(t);
+            return /* @__PURE__ */ x(me, { isDisabled: g, children: /* @__PURE__ */ x(
+              ne,
+              {
+                className: p ? "truncated-cell" : "",
+                "data-truncated": p ? "true" : "false",
+                display: "inline-block",
+                h: "100%",
+                minW: "0",
+                maxW: "100%",
+                position: "relative",
+                overflow: "hidden",
+                cursor: g ? "not-allowed" : "text",
+                children: S.render ? S.render({
+                  value: k(I),
+                  row: t,
+                  column: S
+                }) : k(I)
+              }
+            ) }, S.id);
+          } }),
+          /* @__PURE__ */ x(
+            me,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "pin-row-cell",
+              isDisabled: g,
+              children: /* @__PURE__ */ x(
+                ne,
+                {
+                  "data-slot": M ? "nimbus-table-cell-pin-button-pinned" : "nimbus-table-cell-pin-button",
+                  children: /* @__PURE__ */ A(Oe.Root, { children: [
+                    /* @__PURE__ */ x(
+                      Ft,
+                      {
+                        size: "2xs",
+                        variant: "ghost",
+                        "aria-label": M ? "Unpin row" : "Pin row",
+                        colorPalette: "primary",
+                        onClick: (S) => {
+                          S.stopPropagation(), y(t.id);
+                        },
+                        children: /* @__PURE__ */ x(tn, {})
+                      },
+                      "pin-btn"
+                    ),
+                    /* @__PURE__ */ x(Oe.Content, { placement: "top", children: M ? "Unpin row" : "Pin row" })
+                  ] })
+                }
+              )
+            }
+          )
+        ]
+      }
+    ) }),
+    c && /* @__PURE__ */ x(Bt, { ...$, asChild: !0, children: /* @__PURE__ */ x(
+      Tt,
+      {
+        "data-nested-row-expanded": F ? "true" : "false",
+        dependencies: [F],
+        children: /* @__PURE__ */ x(
+          me,
+          {
+            isDisabled: g,
+            colSpan: o.length + (c ? 1 : 0) + (r ? 1 : 0) + 1,
+            "data-nested-cell": !0,
+            children: F ? u && Array.isArray(t[u]) ? `${t[u].length} nested items` : u && t[u] : null
+          }
+        )
+      }
+    ) })
+  ] });
+};
+ht.displayName = "DataTable.Row";
+const fi = () => /* @__PURE__ */ x(ne, { w: "100%", p: "200", children: "No Data" }), bt = ({
+  ref: t,
+  ...e
+}) => {
+  const { sortedRows: l, activeColumns: n, renderEmptyState: o } = ce(), [i, a] = ke(e);
+  return /* @__PURE__ */ x(Qo, { asChild: !0, ...i, children: /* @__PURE__ */ x(
+    Wo,
+    {
+      ref: t,
+      items: l,
+      dependencies: [n],
+      renderEmptyState: o ?? fi,
+      ...a,
+      children: (s) => /* @__PURE__ */ x(ht, { row: s }, s.id)
+    }
+  ) });
+};
+bt.displayName = "DataTable.Body";
+const gt = function({
+  ref: e,
+  children: l,
+  ...n
+}) {
+  const o = T(null), i = J(Pe(o, e));
+  return /* @__PURE__ */ x(ei, { ref: i, ...n, children: l });
+};
+gt.displayName = "DataTable.Footer";
+function pi(t) {
+  return "onRemoveItem" in t && typeof t.onRemoveItem == "function";
+}
+const mi = ({
+  hiddenItems: t,
+  visibleItems: e,
+  handleVisibleColumnsUpdate: l,
+  handleResetColumns: n
+}) => {
+  const [o, i] = X(""), a = he(be);
+  if (!t || !e)
+    return null;
+  const s = K(() => t.filter(
+    (r) => r.label?.toString().toLowerCase().includes(o.toLowerCase())
+  ), [t, o]), u = (r) => {
+    i(r);
+  }, d = V(
+    (r) => {
+      const p = new Set(t.map((v) => v.id)), f = new Set(
+        r.map((v) => v.id)
+      ), m = t.filter(
+        (v) => !f.has(v.id)
+      ), h = r.filter(
+        (v) => !p.has(v.id)
+      );
+      let y = [...e];
+      if (m.length > 0 && (y = [...y, ...m]), h.length > 0) {
+        const v = new Set(h.map(($) => $.id));
+        y = y.filter(
+          ($) => !v.has($.id)
+        );
+      }
+      l(y);
+    },
+    [t, e, l]
+  ), c = V(
+    (r) => {
+      l(r);
+    },
+    [l]
+  );
+  return /* @__PURE__ */ A(He, { mt: "800", children: [
+    /* @__PURE__ */ A(xe, { gap: "400", width: "100%", columns: 2, children: [
+      /* @__PURE__ */ A(ne, { children: [
+        /* @__PURE__ */ A(He, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(ln, {}),
+          /* @__PURE__ */ x(Re, { fontWeight: "700", fontSize: "sm", w: "full", children: a.format("hiddenColumns") })
+        ] }),
+        /* @__PURE__ */ A(
+          He,
+          {
+            colorPalette: "primary",
+            border: "{sizes.25} solid",
+            borderColor: "colorPalette.3",
+            borderRadius: "200",
+            gap: "200",
+            p: "300",
+            h: "lg",
+            children: [
+              /* @__PURE__ */ x(
+                pn,
+                {
+                  w: "full",
+                  size: "sm",
+                  variant: "ghost",
+                  placeholder: a.format("searchHiddenColumns"),
+                  "aria-label": a.format("searchHiddenColumns"),
+                  onChange: u,
+                  value: o,
+                  "data-testid": "search-hidden-columns"
+                }
+              ),
+              /* @__PURE__ */ x(
+                Nt,
+                {
+                  colorPalette: "primary",
+                  border: "{sizes.25} solid",
+                  borderColor: "colorPalette.3"
+                }
+              ),
+              /* @__PURE__ */ x(
+                Ve.Root,
+                {
+                  border: "none",
+                  borderColor: "none",
+                  h: "full",
+                  w: "full",
+                  overflowY: "auto",
+                  items: s,
+                  onUpdateItems: d,
+                  "aria-label": a.format("hiddenColumnsAriaLabel"),
+                  "data-testid": "hidden-columns-list",
+                  renderEmptyState: /* @__PURE__ */ x(Re, { fontSize: "sm", color: "gray.9", children: a.format("noHiddenColumns") }),
+                  children: (r) => /* @__PURE__ */ x(
+                    Ve.Item,
+                    {
+                      py: "100",
+                      id: r.id,
+                      "aria-label": r.label?.toString() ?? r.id,
+                      children: r.label
+                    },
+                    r.id
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ A(ne, { children: [
+        /* @__PURE__ */ A(He, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(nn, {}),
+          /* @__PURE__ */ x(Re, { fontWeight: "700", fontSize: "sm", children: a.format("visibleColumnsList") })
+        ] }),
+        /* @__PURE__ */ x(
+          Ve.Root,
+          {
+            removableItems: !0,
+            p: "300",
+            h: "lg",
+            overflowY: "auto",
+            items: e,
+            onUpdateItems: c,
+            "aria-label": a.format("visibleColumnsAria"),
+            "data-testid": "visible-columns-list",
+            children: (r) => /* @__PURE__ */ x(
+              Ve.Item,
+              {
+                py: "100",
+                id: r.id,
+                onRemoveItem: pi(r) ? r.onRemoveItem : void 0,
+                "aria-label": r.label?.toString() ?? r.id,
+                children: r.label
+              },
+              r.id
+            )
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ x(ne, { children: /* @__PURE__ */ A(
+      hn,
+      {
+        variant: "ghost",
+        colorPalette: "primary",
+        size: "xs",
+        onClick: n,
+        "aria-label": a.format("reset"),
+        children: [
+          /* @__PURE__ */ x(on, {}),
+          a.format("reset")
+        ]
+      }
+    ) })
+  ] });
+}, Mt = {
+  TOGGLE_TEXT_VISIBILITY: "toggleTextVisibility",
+  TOGGLE_ROW_DENSITY: "toggleRowDensity"
+}, hi = ({
+  onSettingsChange: t
+}) => {
+  const e = he(be), l = ce(), n = l.isTruncated ?? !1, o = l.density === "condensed" ? "compact" : "comfortable", i = (s) => {
+    Array.from(s)[0] && t?.(Mt.TOGGLE_TEXT_VISIBILITY);
+  }, a = (s) => {
+    Array.from(s)[0] && t?.(Mt.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(Re, { fontWeight: "500", children: e.format("textVisibility") }) }),
+        /* @__PURE__ */ x(xe.Item, { colSpan: 3, children: /* @__PURE__ */ x(wt, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Dt.Root,
+          {
+            w: "full",
+            selectedKeys: n ? ["preview"] : ["full"],
+            onSelectionChange: i,
+            "aria-label": e.format("textVisibilityAriaLabel"),
+            children: [
+              /* @__PURE__ */ A(
+                We,
+                {
+                  id: "full",
+                  size: "xs",
+                  "aria-label": e.format("fullText"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(rn, {}),
+                    e.format("fullText")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                We,
+                {
+                  id: "preview",
+                  size: "xs",
+                  "aria-label": e.format("textPreviews"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(an, {}),
+                    e.format("textPreviews")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) }),
+        /* @__PURE__ */ x(xe.Item, { colSpan: 1, children: /* @__PURE__ */ x(Re, { fontWeight: "500", children: e.format("rowDensity") }) }),
+        /* @__PURE__ */ x(xe.Item, { colSpan: 3, children: /* @__PURE__ */ x(wt, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Dt.Root,
+          {
+            w: "full",
+            colorPalette: "primary",
+            selectedKeys: [o],
+            onSelectionChange: a,
+            "aria-label": e.format("rowDensityAriaLabel"),
+            children: [
+              /* @__PURE__ */ A(
+                We,
+                {
+                  id: "comfortable",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("comfortable"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(sn, {}),
+                    e.format("comfortable")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                We,
+                {
+                  id: "compact",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("compact"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(un, {}),
+                    e.format("compact")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) })
+      ]
+    }
+  );
+}, Xl = () => {
+  const [t, e] = X(!1), l = ce(), n = he(be), {
+    columns: o,
+    visibleColumns: i,
+    onColumnsChange: a,
+    onSettingsChange: s
+    // customSettings,
+  } = l, u = o.filter(
+    ($) => !i?.includes($.id)
+  ), { customSettings: d } = ii(), c = T(o);
+  se(() => {
+    c.current = o;
+  }, [o]);
+  const r = T(o), p = T(i), f = T(i || []);
+  if (!i || !u)
+    return null;
+  const m = K(() => ($) => {
+    const b = $.map((D) => D.id);
+    if (!(b.length !== f.current.length || b.some(
+      (D, R) => D !== f.current[R]
+    )))
+      return;
+    const g = new Map(c.current.map((D) => [D.id, D])), w = $.map((D) => g.get(D.id)).filter(
+      (D) => D !== void 0
+    );
+    f.current = b, a && a(w);
+  }, []), h = K(() => o.filter(($) => !i?.includes($.id)).map(($) => ({
+    key: $.id,
+    id: $.id,
+    label: $.header
+  })), [i, o]), y = K(() => {
+    if (!i || i.length === 0)
+      return [];
+    const $ = new Map(o.map((b) => [b.id, b]));
+    return i.map((b) => {
+      const C = $.get(b);
+      return C ? {
+        key: C.id,
+        id: C.id,
+        label: C.header
+      } : null;
+    }).filter((b) => b !== null);
+  }, [o, i]), v = V(() => {
+    if (a) {
+      const $ = p.current;
+      if ($ && $.length > 0) {
+        const b = new Map(
+          r.current.map((g) => [g.id, g])
+        ), C = $.map((g) => b.get(g)).filter(
+          (g) => g !== void 0
+        );
+        f.current = $, a(C);
+      } else
+        f.current = r.current.map(
+          (b) => b.id
+        ), a(r.current);
+    }
+  }, [a]);
+  return /* @__PURE__ */ A(ze, { children: [
+    /* @__PURE__ */ A(Oe.Root, { children: [
+      /* @__PURE__ */ x(Oe.Content, { placement: "top", children: n.format("settings") }),
+      /* @__PURE__ */ x(
+        Ft,
+        {
+          variant: "ghost",
+          colorPalette: "primary",
+          size: "xs",
+          "aria-label": n.format("settings"),
+          onClick: () => e(!0),
+          children: /* @__PURE__ */ x(dn, {})
+        }
+      )
+    ] }),
+    /* @__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", 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(
+            bn.Root,
+            {
+              tabs: [
+                {
+                  id: "visible-columns",
+                  tabLabel: /* @__PURE__ */ A(ze, { children: [
+                    /* @__PURE__ */ x(cn, {}),
+                    n.format("visibleColumns")
+                  ] }),
+                  panelContent: /* @__PURE__ */ x(
+                    mi,
+                    {
+                      hiddenItems: h,
+                      visibleItems: y,
+                      handleVisibleColumnsUpdate: m,
+                      handleResetColumns: v
+                    }
+                  )
+                },
+                {
+                  id: "layout-settings",
+                  tabLabel: /* @__PURE__ */ A(ze, { children: [
+                    /* @__PURE__ */ x(fn, {}),
+                    n.format("layoutSettings")
+                  ] }),
+                  panelContent: /* @__PURE__ */ x(hi, { onSettingsChange: s })
+                },
+                d ? {
+                  id: "custom-settings",
+                  tabLabel: /* @__PURE__ */ A(ze, { children: [
+                    d?.icon ?? null,
+                    d?.label
+                  ] }),
+                  panelContent: /* @__PURE__ */ x(ne, { mt: "800", children: d.panel })
+                } : null
+                // Filter out null values when no custom settings are provided
+              ].filter(($) => $ !== null)
+            }
+          ) })
+        ] })
+      }
+    )
+  ] });
+};
+Xl.displayName = "DataTable.Manager";
+const bi = function({
+  ref: e,
+  footer: l,
+  ...n
+}) {
+  const o = he(be), i = T(null), a = J(Pe(i, e));
+  return /* @__PURE__ */ A(ft, { ref: a, ...n, children: [
+    /* @__PURE__ */ A(pt, { "aria-label": o.format("dataTable"), children: [
+      /* @__PURE__ */ x(mt, { "aria-label": o.format("dataTableHeader") }),
+      /* @__PURE__ */ x(bt, { "aria-label": o.format("dataTableBody") })
+    ] }),
+    l && /* @__PURE__ */ x(gt, { children: l })
+  ] });
+}, kr = /* @__PURE__ */ Object.assign(bi, {
+  /**
+   * # 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: ft,
+  /**
+   * # 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: pt,
+  /**
+   * # 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: mt,
+  /**
+   * # DataTable.Column
+   *
+   * Individual column header component that handles sorting interactions and displays column content.
+   * Used internally by Header but can be used for custom header implementations.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header>
+   *       <DataTable.Column column={customColumn} />
+   *     </DataTable.Header>
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Column: Ce,
+  /**
+   * # 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: bt,
+  /**
+   * # DataTable.Row
+   *
+   * Individual row component that renders data cells and handles row-level interactions.
+   * Supports selection, expansion, and click handlers for custom row actions.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body>
+   *       <DataTable.Row row={customRow} />
+   *     </DataTable.Body>
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Row: ht,
+  /**
+   * # DataTable.Cell
+   *
+   * Individual cell component that displays data values with proper accessibility attributes.
+   * Supports custom rendering and truncation based on table configuration.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body>
+   *       <DataTable.Row>
+   *         <DataTable.Cell>Custom cell content</DataTable.Cell>
+   *       </DataTable.Row>
+   *     </DataTable.Body>
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Cell: me,
+  /**
+   * # 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: gt,
+  /**
+   * # 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: Xl,
+  /**
+   * # DataTable.ExpandButton
+   *
+   * Button component for expanding/collapsing nested rows in hierarchical data.
+   * Automatically shown when data contains nested structures.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.ExpandButton
+   *   isExpanded={expanded}
+   *   onPress={() => toggleExpand(rowId)}
+   * />
+   * ```
+   */
+  ExpandButton: jl,
+  /**
+   * # DataTable.NestedIcon
+   *
+   * Icon component that indicates the nesting level and expansion state of hierarchical rows.
+   * Provides visual hierarchy cues for nested data structures.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.NestedIcon
+   *   depth={2}
+   *   isExpanded={expanded}
+   *   hasChildren={hasChildren}
+   * />
+   * ```
+   */
+  NestedIcon: li,
+  /**
+   * # DataTable.SelectionCell
+   *
+   * Specialized cell component that contains selection checkboxes or radio buttons.
+   * Handles row selection state and provides accessible selection controls.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.SelectionCell
+   *   isSelected={selected}
+   *   onSelectionChange={handleSelection}
+   * />
+   * ```
+   */
+  SelectionCell: ti,
+  /**
+   * # DataTable.Context
+   *
+   * React context that provides shared state and configuration to all table components.
+   * Used internally for component coordination - not typically used directly.
+   *
+   * @example
+   * ```tsx
+   * const context = useContext(DataTable.Context);
+   * ```
+   */
+  Context: qe,
+  /**
+   * # DataTable.useDataTableContext
+   *
+   * Hook that provides access to the DataTable context with proper error handling.
+   * Throws an error if used outside of a DataTable.Root provider.
+   *
+   * @example
+   * ```tsx
+   * const { columns, rows, sortDescriptor } = DataTable.useDataTableContext();
+   * ```
+   */
+  useDataTableContext: ce
+});
+export {
+  kr as D,
+  Mt as U,
+  ft as a,
+  pt as b,
+  mt as c,
+  Ce as d,
+  bt as e,
+  ht as f,
+  me as g,
+  gt as h,
+  Xl as i,
+  jl as j,
+  li as k,
+  ti as l
+};
+//# sourceMappingURL=data-table-DA4SdIgU.es.js.map