@commercetools/nimbus 0.0.0-canary-20251027194157 → 0.0.0-canary-20251028144530

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

@@ -0,0 +1,4176 @@
+import { jsx as x, jsxs as A, Fragment as We } from "react/jsx-runtime";
+import E, { useRef as M, useMemo as N, useCallback as W, useEffect as de, useState as q, forwardRef as Oe, createContext as me, useContext as B } from "react";
+import { defineMessages as Yl, useIntl as he } from "react-intl";
+import { createSlotRecipeContext as Xl, mergeRefs as Re } from "@chakra-ui/react";
+import { $ as Pt } from "./Button-SjGHt140.es.js";
+import { a as Bt, b as $t, c as ql } from "./RSPContexts-DLgb84PF.es.js";
+import { f as L, m as ue, n as ae, o as Ke, e as Zl, g as Nt, a as Kt, c as Jl, b as Ql, h as ee, k as Ft } from "./SelectionManager-S9Amkvfg.es.js";
+import { $ as It, a as ce, e as je, g as xt, d as _l } from "./utils-_m_bPtjI.es.js";
+import { e as Ce, g as en, f as tn, h as ln, i as gi } from "./ListBox-CdtzuZzA.es.js";
+import { $ as nn } from "./intlStrings-Cd44R5hT.es.js";
+import { a as on, $ as rn } from "./SelectionIndicator-B27AsfqE.es.js";
+import { d as _e, $ as Vt, c as Te, g as an, i as un, j as sn, a as Ue, k as dn, h as xi } from "./CollectionBuilder-BhYUxJYI.es.js";
+import { d as Ee, a as et, $ as O, e as cn, c as Dt } from "./mergeProps-DtKAFxbD.es.js";
+import { $ as te } from "./filterDOMProps-BSVCO5jK.es.js";
+import { $ as Q } from "./useObjectRef-CaJ5pgjX.es.js";
+import { c as fn } from "./OverlayArrow-DAfsQzBF.es.js";
+import { c as ge, a as tt, $ as pn } from "./scrollIntoView-CRn_Y0bq.es.js";
+import { b as zi } from "./useListState-BFNT8oUW.es.js";
+import mn from "react-dom";
+import { $ as Ae } from "./useHover-B62SXQZ1.es.js";
+import { d as Ct } from "./platform-Z5fvtFmM.es.js";
+import { a as hn, b as bn, $ as Wt } from "./usePress-HeLch-fy.es.js";
+import { $ as gn, c as vn } from "./useFocusable-Dhchq_tH.es.js";
+import { $ as yn, f as $n } from "./useFocusVisible-Cqoc10KD.es.js";
+import { $ as _ } from "./focusSafely-BNN5-xvK.es.js";
+import { a as wt, b as xn } from "./FocusScope-C6u6zr_m.es.js";
+import { $ as ve } from "./getScrollParent-g7luwBTz.es.js";
+import { $ as we } from "./context-DW7UvQ8z.es.js";
+import { $ as Me } from "./useLocalizedStringFormatter-DaRRUvyV.es.js";
+import { $ as De } from "./useFocusRing-4xTd5aPf.es.js";
+import { $ as Dn } from "./useGlobalListeners-BOOfV5Wh.es.js";
+import { a as Ge, $ as St } from "./VisuallyHidden-Dkq7SL0E.es.js";
+import { e as Cn } from "./openLink-BNz58j4a.es.js";
+import { m as He } from "./utils-Be2JRmv-.es.js";
+import { $ as wn, D as Fe } from "./draggable-list-BpEm-5VK.es.js";
+import { e as Sn, c as kn } from "./Header-CpF5ynyj.es.js";
+import { $ as En } from "./LiveAnnouncer-CsPyaceH.es.js";
+import { d as zn, e as Rn } from "./useGridListItem-WBYPB9KF.es.js";
+import { $ as Ht } from "./useCollator-BjnMaGJd.es.js";
+import { $ as Tn } from "./useHasTabbableChild-Dd6zlnRC.es.js";
+import { $ as An } from "./useUpdateEffect-CCDx8D4X.es.js";
+import { e as Se } from "./extract-style-props-2276ZL5_.es.js";
+import { Highlight as Mn } from "@chakra-ui/react/highlight";
+import { KeyboardArrowDown as Pn, KeyboardArrowRight as Bn, PushPin as Nn, ArrowDownward as Kn, VisibilityOff as Fn, Visibility as In, Refresh as Vn, WrapText as Wn, ShortText as Hn, DensitySmall as Ln, FormatAlignJustify as On, Settings as jn, ViewWeek as Un, ViewDay as Gn } from "@commercetools/nimbus-icons";
+import { B as se } from "./box-DuBoAZvq.es.js";
+import { C as Lt } from "./checkbox-CJKCPfWz.es.js";
+import { b as Le } from "./tooltip-CDmtIjmS.es.js";
+import { I as Ot } from "./icon-button-CKpO4Zvy.es.js";
+import { Flex as Yn } from "@chakra-ui/react/flex";
+import { S as jt } from "./separator-BwUlkA4z.es.js";
+import { S as $e } from "./simple-grid-DU5v66TG.es.js";
+import { S as Ie } from "./stack-CoNreM7B.es.js";
+import { T as ze } from "./text-BVYJmhjj.es.js";
+import { S as Xn } from "./search-input-9M9ZUejR.es.js";
+import { B as qn } from "./button-BYK9-Rwz.es.js";
+import { T as kt } from "./toolbar-ckQGv75h.es.js";
+import { T as Et } from "./toggle-button-group-CjWoTw03.es.js";
+import { I as Ve } from "./icon-toggle-button-kGtDXkhR.es.js";
+import { D as ye } from "./drawer-CqM2ImTR.es.js";
+import { T as Zn } from "./tabs-DkXwV7Rn.es.js";
+function Jn(t) {
+  let { onMoveStart: e, onMove: l, onMoveEnd: n } = t, o = M({
+    didMove: !1,
+    lastPosition: null,
+    id: null
+  }), { addGlobalListener: i, removeGlobalListener: a } = Dn(), u = Ee((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
+    }));
+  }), s = Ee((c, r) => {
+    hn(), o.current.didMove && n?.({
+      type: "moveend",
+      pointerType: r,
+      shiftKey: c.shiftKey,
+      metaKey: c.metaKey,
+      ctrlKey: c.ctrlKey,
+      altKey: c.altKey
+    });
+  });
+  return {
+    moveProps: N(() => {
+      let c = {}, r = () => {
+        bn(), o.current.didMove = !1;
+      };
+      if (typeof PointerEvent > "u" && process.env.NODE_ENV === "test") {
+        let f = (b) => {
+          if (b.button === 0) {
+            var $, g, D, v;
+            u(b, "mouse", b.pageX - ((D = ($ = o.current.lastPosition) === null || $ === void 0 ? void 0 : $.pageX) !== null && D !== void 0 ? D : 0), b.pageY - ((v = (g = o.current.lastPosition) === null || g === void 0 ? void 0 : g.pageY) !== null && v !== void 0 ? v : 0)), o.current.lastPosition = {
+              pageX: b.pageX,
+              pageY: b.pageY
+            };
+          }
+        }, m = (b) => {
+          b.button === 0 && (s(b, "mouse"), a(window, "mousemove", f, !1), a(window, "mouseup", m, !1));
+        };
+        c.onMouseDown = (b) => {
+          b.button === 0 && (r(), b.stopPropagation(), b.preventDefault(), o.current.lastPosition = {
+            pageX: b.pageX,
+            pageY: b.pageY
+          }, i(window, "mousemove", f, !1), i(window, "mouseup", m, !1));
+        };
+        let h = (b) => {
+          let $ = [
+            ...b.changedTouches
+          ].findIndex(({ identifier: S }) => S === o.current.id);
+          if ($ >= 0) {
+            var g, D;
+            let { pageX: S, pageY: P } = b.changedTouches[$];
+            var v, C;
+            u(b, "touch", S - ((v = (g = o.current.lastPosition) === null || g === void 0 ? void 0 : g.pageX) !== null && v !== void 0 ? v : 0), P - ((C = (D = o.current.lastPosition) === null || D === void 0 ? void 0 : D.pageY) !== null && C !== void 0 ? C : 0)), o.current.lastPosition = {
+              pageX: S,
+              pageY: P
+            };
+          }
+        }, y = (b) => {
+          [
+            ...b.changedTouches
+          ].findIndex(({ identifier: g }) => g === o.current.id) >= 0 && (s(b, "touch"), o.current.id = null, a(window, "touchmove", h), a(window, "touchend", y), a(window, "touchcancel", y));
+        };
+        c.onTouchStart = (b) => {
+          if (b.changedTouches.length === 0 || o.current.id != null) return;
+          let { pageX: $, pageY: g, identifier: D } = b.changedTouches[0];
+          r(), b.stopPropagation(), b.preventDefault(), o.current.lastPosition = {
+            pageX: $,
+            pageY: g
+          }, o.current.id = D, 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, b;
+            let D = h.pointerType || "mouse";
+            var $, g;
+            u(h, D, h.pageX - (($ = (y = o.current.lastPosition) === null || y === void 0 ? void 0 : y.pageX) !== null && $ !== void 0 ? $ : 0), h.pageY - ((g = (b = o.current.lastPosition) === null || b === void 0 ? void 0 : b.pageY) !== null && g !== void 0 ? g : 0)), o.current.lastPosition = {
+              pageX: h.pageX,
+              pageY: h.pageY
+            };
+          }
+        }, m = (h) => {
+          if (h.pointerId === o.current.id) {
+            let y = h.pointerType || "mouse";
+            s(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(), u(f, "keyboard", m, h), s(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,
+      u,
+      s
+    ])
+  };
+}
+class Ut {
+  isCell(e) {
+    return e.type === "cell";
+  }
+  isRow(e) {
+    return e.type === "row" || e.type === "item";
+  }
+  isDisabled(e) {
+    var l;
+    return this.disabledBehavior === "all" && (((l = e.props) === null || l === void 0 ? void 0 : l.isDisabled) || this.disabledKeys.has(e.key));
+  }
+  findPreviousKey(e, l) {
+    let n = e != null ? this.collection.getKeyBefore(e) : this.collection.getLastKey();
+    for (; n != null; ) {
+      let o = this.collection.getItem(n);
+      if (!o) return null;
+      if (!this.isDisabled(o) && (!l || l(o))) return n;
+      n = this.collection.getKeyBefore(n);
+    }
+    return null;
+  }
+  findNextKey(e, l) {
+    let n = e != null ? this.collection.getKeyAfter(e) : this.collection.getFirstKey();
+    for (; n != null; ) {
+      let o = this.collection.getItem(n);
+      if (!o) return null;
+      if (!this.isDisabled(o) && (!l || l(o))) return n;
+      if (n = this.collection.getKeyAfter(n), n == null) return null;
+    }
+    return null;
+  }
+  getKeyForItemInRowByIndex(e, l = 0) {
+    if (l < 0) return null;
+    let n = this.collection.getItem(e);
+    if (!n) return null;
+    let o = 0;
+    for (let u of L(n, this.collection)) {
+      var i;
+      if (u.colSpan && u.colSpan + o > l) return (i = u.key) !== null && i !== void 0 ? i : null;
+      u.colSpan && (o = o + u.colSpan - 1);
+      var a;
+      if (o === l) return (a = u.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 = L(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = ue(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 = L(c, this.collection);
+      var a;
+      let p = (a = this.direction === "rtl" ? Ke(r, l.index - 1) : Ke(r, l.index + 1)) !== null && a !== void 0 ? a : null;
+      var u;
+      if (p) return (u = p.key) !== null && u !== void 0 ? u : null;
+      var s;
+      if (this.focusMode === "row") return (s = l.parentKey) !== null && s !== void 0 ? s : 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 = L(l, this.collection);
+      var i;
+      return (i = this.direction === "rtl" ? (n = ae(c)) === null || n === void 0 ? void 0 : n.key : (o = ue(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 = L(c, this.collection);
+      var a;
+      let p = (a = this.direction === "rtl" ? Ke(r, l.index + 1) : Ke(r, l.index - 1)) !== null && a !== void 0 ? a : null;
+      var u;
+      if (p) return (u = p.key) !== null && u !== void 0 ? u : null;
+      var s;
+      if (this.focusMode === "row") return (s = l.parentKey) !== null && s !== void 0 ? s : 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 = ae(L(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 u;
+      let d = this.collection.getItem(n);
+      if (!d) return null;
+      var s;
+      n = (s = (u = ae(L(d, this.collection))) === null || u === void 0 ? void 0 : u.key) !== null && s !== void 0 ? s : null;
+    }
+    return n;
+  }
+  getLastKey(e, l) {
+    let n = e ?? null, o;
+    if (n != null) {
+      if (o = this.collection.getItem(n), !o) return null;
+      if (this.isCell(o) && !l && o.parentKey != null) {
+        var i;
+        let d = this.collection.getItem(o.parentKey);
+        if (!d) return null;
+        let c = L(d, this.collection);
+        var a;
+        return (a = (i = ue(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 u;
+      let d = this.collection.getItem(n);
+      if (!d) return null;
+      let c = L(d, this.collection);
+      var s;
+      n = (s = (u = ue(c)) === null || u === void 0 ? void 0 : u.key) !== null && s !== void 0 ? s : null;
+    }
+    return n;
+  }
+  getKeyPageAbove(e) {
+    let l = e, n = this.layoutDelegate.getItemRect(l);
+    if (!n) return null;
+    let o = Math.max(0, n.y + n.height - this.layoutDelegate.getVisibleRect().height);
+    for (; n && n.y > o && l != null; ) {
+      var i;
+      if (l = (i = this.getKeyAbove(l)) !== null && i !== void 0 ? i : null, l == null) break;
+      n = this.layoutDelegate.getItemRect(l);
+    }
+    return l;
+  }
+  getKeyPageBelow(e) {
+    let l = e, n = this.layoutDelegate.getItemRect(l);
+    if (!n) return null;
+    let o = this.layoutDelegate.getVisibleRect().height, i = Math.min(this.layoutDelegate.getContentSize().height, n.y + o);
+    for (; n && n.y + n.height < i; ) {
+      let 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 u = !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 s, d;
+          return this.isRow(c) && this.focusMode === "cell" ? (d = (s = ae(L(c, this.collection))) === null || s === void 0 ? void 0 : s.key) !== null && d !== void 0 ? d : null : c.key;
+        }
+      }
+      n = this.findNextKey(n, (r) => r.type === "item"), n == null && !u && (n = this.getFirstKey(), u = !0);
+    }
+    return null;
+  }
+  constructor(e) {
+    if (this.collection = e.collection, this.disabledKeys = e.disabledKeys, this.disabledBehavior = e.disabledBehavior || "all", this.direction = e.direction, this.collator = e.collator, !e.layout && !e.ref) throw new Error("Either a layout or a ref must be specified.");
+    this.layoutDelegate = e.layoutDelegate || (e.layout ? new Qn(e.layout) : new Sn(e.ref));
+    var l;
+    this.focusMode = (l = e.focusMode) !== null && l !== void 0 ? l : "row";
+  }
+}
+class Qn {
+  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 lt = /* @__PURE__ */ new WeakMap();
+function _n(t, e, l) {
+  let { isVirtualized: n, disallowTypeAhead: o, keyboardDelegate: i, focusMode: a, scrollRef: u, getRowText: s, 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 = Ht({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: h } = we(), y = e.selectionManager.disabledBehavior, b = N(() => i || new Ut({
+    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: $ } = Zl({
+    ref: l,
+    selectionManager: f,
+    keyboardDelegate: b,
+    isVirtualized: n,
+    scrollRef: u,
+    disallowTypeAhead: o,
+    escapeKeyBehavior: r
+  }), g = et(t.id);
+  lt.set(e, {
+    keyboardDelegate: b,
+    actions: {
+      onRowAction: d,
+      onCellAction: c
+    },
+    shouldSelectOnPressUp: p
+  });
+  let D = zn({
+    selectionManager: f,
+    hasItemActions: !!(d || c)
+  }), v = te(t, {
+    labelable: !0
+  }), C = W((z) => {
+    if (f.isFocused) {
+      z.currentTarget.contains(z.target) || f.setFocused(!1);
+      return;
+    }
+    z.currentTarget.contains(z.target) && f.setFocused(!0);
+  }, [
+    f
+  ]), S = N(() => ({
+    onBlur: $.onBlur,
+    onFocus: C
+  }), [
+    C,
+    $.onBlur
+  ]), P = Tn(l, {
+    isDisabled: e.collection.size !== 0
+  }), T = O(
+    v,
+    {
+      role: "grid",
+      id: g,
+      "aria-multiselectable": f.selectionMode === "multiple" ? "true" : void 0
+    },
+    e.isKeyboardNavigationDisabled ? S : $,
+    // If collection is empty, make sure the grid is tabbable unless there is a child tabbable element.
+    e.collection.size === 0 && {
+      tabIndex: P ? -1 : 0
+    } || void 0,
+    D
+  );
+  return n && (T["aria-rowcount"] = e.collection.size, T["aria-colcount"] = e.collection.columnCount), Rn({
+    getRowText: s
+  }, e), {
+    gridProps: T
+  };
+}
+function eo() {
+  return {
+    rowGroupProps: {
+      role: "rowgroup"
+    }
+  };
+}
+function to(t, e, l) {
+  var n, o;
+  let { node: i, isVirtualized: a, shouldSelectOnPressUp: u, onAction: s } = t, { actions: d, shouldSelectOnPressUp: c } = lt.get(e), r = d.onRowAction ? () => {
+    var y;
+    return (y = d.onRowAction) === null || y === void 0 ? void 0 : y.call(d, i.key);
+  } : s, { itemProps: p, ...f } = Nt({
+    selectionManager: e.selectionManager,
+    key: i.key,
+    ref: l,
+    isVirtualized: a,
+    shouldSelectOnPressUp: c || u,
+    onAction: r || !(i == null || (n = i.props) === null || n === void 0) && n.onAction ? cn(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 Gt(t, e, l) {
+  let { node: n, isVirtualized: o, focusMode: i = "child", shouldSelectOnPressUp: a, onAction: u } = t, { direction: s } = we(), { keyboardDelegate: d, actions: { onCellAction: c } } = lt.get(e), r = M(null), p = () => {
+    if (l.current) {
+      let g = wt(l.current);
+      if (i === "child") {
+        if (l.current.contains(document.activeElement) && l.current !== document.activeElement) return;
+        let D = e.selectionManager.childFocusStrategy === "last" ? qe(g) : g.firstChild();
+        if (D) {
+          _(D);
+          return;
+        }
+      }
+      (r.current != null && n.key !== r.current || !l.current.contains(document.activeElement)) && _(l.current);
+    }
+  }, { itemProps: f, isPressed: m } = Nt({
+    selectionManager: e.selectionManager,
+    key: n.key,
+    ref: l,
+    isVirtualized: o,
+    focus: p,
+    shouldSelectOnPressUp: a,
+    onAction: c ? () => c(n.key) : u,
+    isDisabled: e.collection.size === 0
+  }), h = (g) => {
+    if (!g.currentTarget.contains(g.target) || e.isKeyboardNavigationDisabled || !l.current || !document.activeElement) return;
+    let D = wt(l.current);
+    switch (D.currentNode = document.activeElement, g.key) {
+      case "ArrowLeft": {
+        let z = s === "rtl" ? D.nextNode() : D.previousNode();
+        if (i === "child" && z === l.current && (z = null), g.preventDefault(), g.stopPropagation(), z)
+          _(z), ge(z, {
+            containingElement: ve(l.current)
+          });
+        else {
+          var v;
+          if (((v = d.getKeyLeftOf) === null || v === void 0 ? void 0 : v.call(d, n.key)) !== n.key) {
+            var C;
+            (C = l.current.parentElement) === null || C === void 0 || C.dispatchEvent(new KeyboardEvent(g.nativeEvent.type, g.nativeEvent));
+            break;
+          }
+          i === "cell" && s === "rtl" ? (_(l.current), ge(l.current, {
+            containingElement: ve(l.current)
+          })) : (D.currentNode = l.current, z = s === "rtl" ? D.firstChild() : qe(D), z && (_(z), ge(z, {
+            containingElement: ve(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowRight": {
+        let z = s === "rtl" ? D.previousNode() : D.nextNode();
+        if (i === "child" && z === l.current && (z = null), g.preventDefault(), g.stopPropagation(), z)
+          _(z), ge(z, {
+            containingElement: ve(l.current)
+          });
+        else {
+          var S;
+          if (((S = d.getKeyRightOf) === null || S === void 0 ? void 0 : S.call(d, n.key)) !== n.key) {
+            var P;
+            (P = l.current.parentElement) === null || P === void 0 || P.dispatchEvent(new KeyboardEvent(g.nativeEvent.type, g.nativeEvent));
+            break;
+          }
+          i === "cell" && s === "ltr" ? (_(l.current), ge(l.current, {
+            containingElement: ve(l.current)
+          })) : (D.currentNode = l.current, z = s === "rtl" ? qe(D) : D.firstChild(), z && (_(z), ge(z, {
+            containingElement: ve(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowUp":
+      case "ArrowDown":
+        if (!g.altKey && l.current.contains(g.target)) {
+          var T;
+          g.stopPropagation(), g.preventDefault(), (T = l.current.parentElement) === null || T === void 0 || T.dispatchEvent(new KeyboardEvent(g.nativeEvent.type, g.nativeEvent));
+        }
+        break;
+    }
+  }, y = (g) => {
+    if (r.current = n.key, g.target !== l.current) {
+      yn() || e.selectionManager.setFocusedKey(n.key);
+      return;
+    }
+    requestAnimationFrame(() => {
+      i === "child" && document.activeElement === l.current && p();
+    });
+  }, b = O(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 && (b["aria-colindex"] = (($ = n.colIndex) !== null && $ !== void 0 ? $ : n.index) + 1), a && b.tabIndex != null && b.onPointerDown == null && (b.onPointerDown = (g) => {
+    let D = g.currentTarget, v = D.getAttribute("tabindex");
+    D.removeAttribute("tabindex"), requestAnimationFrame(() => {
+      v != null && D.setAttribute("tabindex", v);
+    });
+  }), {
+    gridCellProps: b,
+    isPressed: m
+  };
+}
+function qe(t) {
+  let e = null, l = null;
+  do
+    l = t.lastChild(), l && (e = l);
+  while (l);
+  return e;
+}
+const nt = /* @__PURE__ */ new WeakMap();
+function Ze(t) {
+  return typeof t == "string" ? t.replace(/\s*/g, "") : "" + t;
+}
+function Yt(t, e) {
+  let l = nt.get(t);
+  if (!l) throw new Error("Unknown grid");
+  return `${l}-${Ze(e)}`;
+}
+function Xt(t, e, l) {
+  let n = nt.get(t);
+  if (!n) throw new Error("Unknown grid");
+  return `${n}-${Ze(e)}-${Ze(l)}`;
+}
+function qt(t, e) {
+  return [
+    ...t.collection.rowHeaderColumnKeys
+  ].map((l) => Xt(t, e, l)).join(" ");
+}
+var Zt = {};
+Zt = {
+  ascending: "تصاعدي",
+  ascendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تصاعدي`,
+  columnSize: (t) => `${t.value} بالبكسل`,
+  descending: "تنازلي",
+  descendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تنازلي`,
+  resizerDescription: "اضغط على مفتاح Enter لبدء تغيير الحجم",
+  select: "تحديد",
+  selectAll: "تحديد الكل",
+  sortable: "عمود قابل للترتيب"
+};
+var Jt = {};
+Jt = {
+  ascending: "възходящ",
+  ascendingSort: (t) => `сортирано по колона ${t.columnName} във възходящ ред`,
+  columnSize: (t) => `${t.value} пиксела`,
+  descending: "низходящ",
+  descendingSort: (t) => `сортирано по колона ${t.columnName} в низходящ ред`,
+  resizerDescription: "Натиснете „Enter“, за да започнете да преоразмерявате",
+  select: "Изберете",
+  selectAll: "Изберете всичко",
+  sortable: "сортираща колона"
+};
+var Qt = {};
+Qt = {
+  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 _t = {};
+_t = {
+  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 el = {};
+el = {
+  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 tl = {};
+tl = {
+  ascending: "αύξουσα",
+  ascendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε αύξουσα σειρά`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "φθίνουσα",
+  descendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε φθίνουσα σειρά`,
+  resizerDescription: "Πατήστε Enter για έναρξη της αλλαγής μεγέθους",
+  select: "Επιλογή",
+  selectAll: "Επιλογή όλων",
+  sortable: "Στήλη διαλογής"
+};
+var ll = {};
+ll = {
+  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 nl = {};
+nl = {
+  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 ol = {};
+ol = {
+  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 il = {};
+il = {
+  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 rl = {};
+rl = {
+  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 al = {};
+al = {
+  ascending: "עולה",
+  ascendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר עולה`,
+  columnSize: (t) => `${t.value} פיקסלים`,
+  descending: "יורד",
+  descendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר יורד`,
+  resizerDescription: "הקש Enter כדי לשנות את הגודל",
+  select: "בחר",
+  selectAll: "בחר הכול",
+  sortable: "עמודה שניתן למיין"
+};
+var ul = {};
+ul = {
+  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 sl = {};
+sl = {
+  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 dl = {};
+dl = {
+  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 cl = {};
+cl = {
+  ascending: "昇順",
+  ascendingSort: (t) => `列 ${t.columnName} を昇順で並べ替え`,
+  columnSize: (t) => `${t.value} ピクセル`,
+  descending: "降順",
+  descendingSort: (t) => `列 ${t.columnName} を降順で並べ替え`,
+  resizerDescription: "Enter キーを押してサイズ変更を開始",
+  select: "選択",
+  selectAll: "すべて選択",
+  sortable: "並べ替え可能な列"
+};
+var fl = {};
+fl = {
+  ascending: "오름차순",
+  ascendingSort: (t) => `${t.columnName} 열을 기준으로 오름차순으로 정렬됨`,
+  columnSize: (t) => `${t.value} 픽셀`,
+  descending: "내림차순",
+  descendingSort: (t) => `${t.columnName} 열을 기준으로 내림차순으로 정렬됨`,
+  resizerDescription: "크기 조정을 시작하려면 Enter를 누르세요.",
+  select: "선택",
+  selectAll: "모두 선택",
+  sortable: "정렬 가능한 열"
+};
+var pl = {};
+pl = {
+  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 ml = {};
+ml = {
+  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 hl = {};
+hl = {
+  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 bl = {};
+bl = {
+  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 gl = {};
+gl = {
+  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 vl = {};
+vl = {
+  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 yl = {};
+yl = {
+  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 $l = {};
+$l = {
+  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 xl = {};
+xl = {
+  ascending: "возрастание",
+  ascendingSort: (t) => `сортировать столбец ${t.columnName} в порядке возрастания`,
+  columnSize: (t) => `${t.value} пикс.`,
+  descending: "убывание",
+  descendingSort: (t) => `сортировать столбец ${t.columnName} в порядке убывания`,
+  resizerDescription: "Нажмите клавишу Enter для начала изменения размеров",
+  select: "Выбрать",
+  selectAll: "Выбрать все",
+  sortable: "сортируемый столбец"
+};
+var Dl = {};
+Dl = {
+  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 Cl = {};
+Cl = {
+  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 wl = {};
+wl = {
+  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 Sl = {};
+Sl = {
+  ascending: "stigande",
+  ascendingSort: (t) => `sorterat på kolumn ${t.columnName} i stigande ordning`,
+  columnSize: (t) => `${t.value} pixlar`,
+  descending: "fallande",
+  descendingSort: (t) => `sorterat på kolumn ${t.columnName} i fallande ordning`,
+  resizerDescription: "Tryck på Retur för att börja ändra storlek",
+  select: "Markera",
+  selectAll: "Markera allt",
+  sortable: "sorterbar kolumn"
+};
+var kl = {};
+kl = {
+  ascending: "artan sırada",
+  ascendingSort: (t) => `${t.columnName} sütuna göre artan düzende sırala`,
+  columnSize: (t) => `${t.value} piksel`,
+  descending: "azalan sırada",
+  descendingSort: (t) => `${t.columnName} sütuna göre azalan düzende sırala`,
+  resizerDescription: "Yeniden boyutlandırmak için Enter'a basın",
+  select: "Seç",
+  selectAll: "Tümünü Seç",
+  sortable: "Sıralanabilir sütun"
+};
+var El = {};
+El = {
+  ascending: "висхідний",
+  ascendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у висхідному порядку`,
+  columnSize: (t) => `${t.value} пікс.`,
+  descending: "низхідний",
+  descendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у низхідному порядку`,
+  resizerDescription: "Натисніть Enter, щоб почати зміну розміру",
+  select: "Вибрати",
+  selectAll: "Вибрати все",
+  sortable: "сортувальний стовпець"
+};
+var zl = {};
+zl = {
+  ascending: "升序",
+  ascendingSort: (t) => `按列 ${t.columnName} 升序排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "降序",
+  descendingSort: (t) => `按列 ${t.columnName} 降序排序`,
+  resizerDescription: "按“输入”键开始调整大小。",
+  select: "选择",
+  selectAll: "全选",
+  sortable: "可排序的列"
+};
+var Rl = {};
+Rl = {
+  ascending: "遞增",
+  ascendingSort: (t) => `已依據「${t.columnName}」欄遞增排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "遞減",
+  descendingSort: (t) => `已依據「${t.columnName}」欄遞減排序`,
+  resizerDescription: "按 Enter 鍵以開始調整大小",
+  select: "選取",
+  selectAll: "全選",
+  sortable: "可排序的欄"
+};
+var Pe = {};
+Pe = {
+  "ar-AE": Zt,
+  "bg-BG": Jt,
+  "cs-CZ": Qt,
+  "da-DK": _t,
+  "de-DE": el,
+  "el-GR": tl,
+  "en-US": ll,
+  "es-ES": nl,
+  "et-EE": ol,
+  "fi-FI": il,
+  "fr-FR": rl,
+  "he-IL": al,
+  "hr-HR": ul,
+  "hu-HU": sl,
+  "it-IT": dl,
+  "ja-JP": cl,
+  "ko-KR": fl,
+  "lt-LT": pl,
+  "lv-LV": ml,
+  "nb-NO": hl,
+  "nl-NL": bl,
+  "pl-PL": gl,
+  "pt-BR": vl,
+  "pt-PT": yl,
+  "ro-RO": $l,
+  "ru-RU": xl,
+  "sk-SK": Dl,
+  "sl-SI": Cl,
+  "sr-SP": wl,
+  "sv-SE": Sl,
+  "tr-TR": kl,
+  "uk-UA": El,
+  "zh-CN": zl,
+  "zh-TW": Rl
+};
+class lo extends Ut {
+  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 = ae(L(l, this.collection));
+      if (n) return n.key;
+      let o = this.getFirstKey();
+      return o == null || !this.collection.getItem(o) ? null : super.getKeyForItemInRowByIndex(o, l.index);
+    }
+    return super.getKeyBelow(e);
+  }
+  getKeyAbove(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (l.type === "column") {
+      let i = l.parentKey != null ? this.collection.getItem(l.parentKey) : null;
+      return i && i.type === "column" ? i.key : null;
+    }
+    let n = super.getKeyAbove(e), o = n != null ? this.collection.getItem(n) : null;
+    return o && o.type !== "headerrow" ? n : this.isCell(l) ? this.collection.columns[l.index].key : this.collection.columns[0].key;
+  }
+  findNextColumnKey(e) {
+    let l = this.findNextKey(e.key, (o) => o.type === "column");
+    if (l != null) return l;
+    let n = this.collection.headerRows[e.level];
+    for (let o of L(n, this.collection))
+      if (o.type === "column") return o.key;
+    return null;
+  }
+  findPreviousColumnKey(e) {
+    let l = this.findPreviousKey(e.key, (i) => i.type === "column");
+    if (l != null) return l;
+    let n = this.collection.headerRows[e.level], o = [
+      ...L(n, this.collection)
+    ];
+    for (let i = o.length - 1; i >= 0; i--) {
+      let 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 u = !1;
+    for (; o != null; ) {
+      let s = n.getItem(o);
+      if (!s) return null;
+      if (s.textValue) {
+        let d = s.textValue.slice(0, e.length);
+        if (this.collator.compare(d, e) === 0) return s.key;
+      }
+      for (let d of L(s, 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 : s.key;
+          }
+        }
+      }
+      o = this.getKeyBelow(o), o == null && !u && (o = this.getFirstKey(), u = !0);
+    }
+    return null;
+  }
+}
+function no(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function oo(t, e, l) {
+  let { keyboardDelegate: n, isVirtualized: o, layoutDelegate: i, layout: a } = t, u = Ht({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: s } = we(), d = e.selectionManager.disabledBehavior, c = N(() => n || new lo({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: d,
+    ref: l,
+    direction: s,
+    collator: u,
+    layoutDelegate: i,
+    layout: a
+  }), [
+    n,
+    e.collection,
+    e.disabledKeys,
+    d,
+    l,
+    s,
+    u,
+    i,
+    a
+  ]), r = et(t.id);
+  nt.set(e, r);
+  let { gridProps: p } = _n({
+    ...t,
+    id: r,
+    keyboardDelegate: c
+  }, e, l);
+  o && (p["aria-rowcount"] = e.collection.size + e.collection.headerRows.length), He() && "expandedKeys" in e && (p.role = "treegrid");
+  let { column: f, direction: m } = e.sortDescriptor || {}, h = Me(no(Pe), "@react-aria/table"), y = N(() => {
+    var $, g;
+    let D = (g = ($ = e.collection.columns.find((v) => v.key === f)) === null || $ === void 0 ? void 0 : $.textValue) !== null && g !== void 0 ? g : "";
+    return m && f ? h.format(`${m}Sort`, {
+      columnName: D
+    }) : void 0;
+  }, [
+    m,
+    f,
+    e.collection.columns
+  ]), b = tt(y);
+  return An(() => {
+    y && En(y, "assertive", 500);
+  }, [
+    y
+  ]), {
+    gridProps: O(p, b, {
+      // merge sort description with long press information
+      "aria-describedby": [
+        b["aria-describedby"],
+        p["aria-describedby"]
+      ].filter(Boolean).join(" ")
+    })
+  };
+}
+function io(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function ro(t, e, l) {
+  var n, o;
+  let { node: i } = t, a = i.props.allowsSorting, { gridCellProps: u } = Gt({
+    ...t,
+    focusMode: "child"
+  }, e, l), s = i.props.isSelectionCell && e.selectionManager.selectionMode === "single", { pressProps: d } = Wt({
+    isDisabled: !a || s,
+    onPress() {
+      e.sort(i.key);
+    },
+    ref: l
+  }), { focusableProps: c } = gn({}, 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 && !Ct() && (r = p ? f : "none");
+  let m = Me(io(Pe), "@react-aria/table"), h;
+  a && (h = `${m.format("sortable")}`, p && f && Ct() && (h = `${h}, ${m.format(f)}`));
+  let y = tt(h), b = e.collection.size === 0;
+  return de(() => {
+    b && e.selectionManager.focusedKey === i.key && e.selectionManager.setFocusedKey(null);
+  }, [
+    b,
+    e.selectionManager,
+    i.key
+  ]), {
+    columnHeaderProps: {
+      ...O(
+        c,
+        u,
+        d,
+        y,
+        // If the table is empty, make all column headers untabbable
+        b ? {
+          tabIndex: -1
+        } : null
+      ),
+      role: "columnheader",
+      id: Yt(e, i.key),
+      "aria-colspan": i.colSpan && i.colSpan > 1 ? i.colSpan : void 0,
+      "aria-sort": r
+    }
+  };
+}
+const zt = {
+  expand: {
+    ltr: "ArrowRight",
+    rtl: "ArrowLeft"
+  },
+  collapse: {
+    ltr: "ArrowLeft",
+    rtl: "ArrowRight"
+  }
+};
+function ao(t, e, l) {
+  let { node: n, isVirtualized: o } = t, { rowProps: i, ...a } = to(t, e, l), { direction: u } = we();
+  o && !(He() && "expandedKeys" in e) ? i["aria-rowindex"] = n.index + 1 + e.collection.headerRows.length : delete i["aria-rowindex"];
+  let s = {};
+  if (He() && "expandedKeys" in e) {
+    let v = e.keyMap.get(n.key);
+    if (v != null) {
+      var d, c, r, p, f, m;
+      let C = ((d = v.props) === null || d === void 0 ? void 0 : d.UNSTABLE_childItems) || ((r = v.props) === null || r === void 0 || (c = r.children) === null || c === void 0 ? void 0 : c.length) > e.userColumnCount;
+      var h, y, b, $;
+      s = {
+        onKeyDown: (S) => {
+          (S.key === zt.expand[u] && e.selectionManager.focusedKey === v.key && C && e.expandedKeys !== "all" && !e.expandedKeys.has(v.key) || S.key === zt.collapse[u] && e.selectionManager.focusedKey === v.key && C && (e.expandedKeys === "all" || e.expandedKeys.has(v.key))) && (e.toggleKey(v.key), S.stopPropagation());
+        },
+        "aria-expanded": C ? e.expandedKeys === "all" || e.expandedKeys.has(n.key) : void 0,
+        "aria-level": v.level,
+        "aria-posinset": ((h = v.indexOfType) !== null && h !== void 0 ? h : 0) + 1,
+        "aria-setsize": v.level > 1 ? ((b = (p = ue((y = (f = e.keyMap.get(v.parentKey)) === null || f === void 0 ? void 0 : f.childNodes) !== null && y !== void 0 ? y : [])) === null || p === void 0 ? void 0 : p.indexOfType) !== null && b !== void 0 ? b : 0) + 1 : (($ = (m = ue(e.collection.body.childNodes)) === null || m === void 0 ? void 0 : m.indexOfType) !== null && $ !== void 0 ? $ : 0) + 1
+      };
+    }
+  }
+  let g = Cn(n.props), D = a.hasAction ? g : {};
+  return {
+    rowProps: {
+      ...O(i, s, D),
+      "aria-labelledby": qt(e, n.key)
+    },
+    ...a
+  };
+}
+function uo(t, e, l) {
+  let { node: n, isVirtualized: o } = t, i = {
+    role: "row"
+  };
+  return o && !(He() && "expandedKeys" in e) && (i["aria-rowindex"] = n.index + 1), {
+    rowProps: i
+  };
+}
+function so(t, e, l) {
+  var n;
+  let { gridCellProps: o, isPressed: i } = Gt(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 = Xt(e, t.node.parentKey, a)), {
+    gridCellProps: o,
+    isPressed: i
+  };
+}
+function co(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function fo(t, e) {
+  let { key: l } = t;
+  const { checkboxProps: n } = wn(t, e);
+  return {
+    checkboxProps: {
+      ...n,
+      "aria-labelledby": `${n.id} ${qt(e, l)}`
+    }
+  };
+}
+function po(t) {
+  let { isEmpty: e, isSelectAll: l, selectionMode: n } = t.selectionManager;
+  return {
+    checkboxProps: {
+      "aria-label": Me(co(Pe), "@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 mo(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function ho(t, e, l) {
+  let { column: n, triggerRef: o, isDisabled: i, onResizeStart: a, onResize: u, onResizeEnd: s, "aria-label": d } = t;
+  const c = Me(mo(Pe), "@react-aria/table");
+  let r = et(), p = e.resizingColumn === n.key, f = M(p), m = M(null), h = M(!1), y = e.tableState.isKeyboardNavigationDisabled, { direction: b } = we(), { keyboardProps: $ } = vn({
+    onKeyDown: (k) => {
+      y ? (k.key === "Escape" || k.key === "Enter" || k.key === " " || k.key === "Tab") && (k.preventDefault(), v(n)) : (k.continuePropagation(), k.key === "Enter" && g(n));
+    }
+  }), g = Ee((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;
+  }), D = Ee((k, w) => {
+    let F = e.updateResizedColumns(k.key, w);
+    u?.(F), m.current = F;
+  }), v = Ee((k) => {
+    f.current && (m.current == null && (m.current = e.updateResizedColumns(k.key, e.getColumnWidth(k.key))), e.endResize(), e.tableState.setKeyboardNavigationDisabled(!1), s?.(m.current), f.current = !1, o?.current && !h.current && _(o.current)), m.current = null;
+  });
+  const C = M(0), { moveProps: S } = Jn({
+    onMoveStart() {
+      C.current = e.getColumnWidth(n.key), g(n);
+    },
+    onMove(k) {
+      let { deltaX: w, deltaY: F, pointerType: re } = k;
+      b === "rtl" && (w *= -1), re === "keyboard" && (F !== 0 && w === 0 && (w = F * -1), w *= 10), w !== 0 && (C.current += w, D(n, C.current));
+    },
+    onMoveEnd(k) {
+      let { pointerType: w } = k;
+      C.current = 0, (w === "mouse" || w === "touch" && h.current) && v(n);
+    }
+  });
+  let P = W((k) => {
+    var w;
+    y && ((w = S.onKeyDown) === null || w === void 0 || w.call(S, k));
+  }, [
+    y,
+    S
+  ]), T = Math.floor(e.getColumnMinWidth(n.key)), z = Math.floor(e.getColumnMaxWidth(n.key));
+  z === 1 / 0 && (z = Number.MAX_SAFE_INTEGER);
+  let I = Math.floor(e.getColumnWidth(n.key)), H = $n();
+  H === "virtual" && typeof window < "u" && "ontouchstart" in window && (H = "touch");
+  let j = o?.current == null && (H === "keyboard" || H === "virtual") && !p ? c.format("resizerDescription") : void 0, V = tt(j), K = {
+    "aria-label": d,
+    "aria-orientation": "horizontal",
+    "aria-labelledby": `${r} ${Yt(e.tableState, n.key)}`,
+    "aria-valuetext": c.format("columnSize", {
+      value: I
+    }),
+    type: "range",
+    min: T,
+    max: z,
+    value: I,
+    ...V
+  };
+  const Y = W(() => {
+    l.current && _(l.current);
+  }, [
+    l
+  ]);
+  let U = e.resizingColumn, le = M(null);
+  de(() => {
+    if (le.current !== U && U != null && U === n.key) {
+      h.current = document.activeElement === l.current, g(n);
+      let k = setTimeout(() => Y(), 0), w = setTimeout(Y, 400);
+      return () => {
+        clearTimeout(k), clearTimeout(w);
+      };
+    }
+    le.current = U;
+  }, [
+    U,
+    n,
+    Y,
+    l,
+    g
+  ]);
+  let pe = (k) => {
+    let w = e.getColumnWidth(n.key), F = parseFloat(k.target.value);
+    F > w ? F = w + 10 : F = w - 10, D(n, F);
+  }, { pressProps: ie } = Wt({
+    preventFocusOnPress: !0,
+    onPressStart: (k) => {
+      if (!(k.ctrlKey || k.altKey || k.metaKey || k.shiftKey || k.pointerType === "keyboard")) {
+        if (k.pointerType === "virtual" && e.resizingColumn != null) {
+          v(n);
+          return;
+        }
+        Y(), k.pointerType !== "virtual" && g(n);
+      }
+    },
+    onPress: (k) => {
+      (k.pointerType === "touch" && h.current || k.pointerType === "mouse") && e.resizingColumn != null && v(n);
+    }
+  }), { visuallyHiddenProps: ne } = Ge();
+  return {
+    resizerProps: O($, {
+      ...S,
+      onKeyDown: P
+    }, ie, {
+      style: {
+        touchAction: "none"
+      }
+    }),
+    inputProps: O(ne, {
+      id: r,
+      onBlur: () => {
+        v(n);
+      },
+      onChange: pe,
+      disabled: i
+    }, K),
+    isResizing: p
+  };
+}
+function Tl() {
+  return eo();
+}
+function bo(t) {
+  return t != null && (!isNaN(t) || String(t).match(/^(\d+)(?=%$)/) !== null);
+}
+function go(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 ot(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 Al(t, e) {
+  return t != null ? ot(t, e) : Number.MAX_SAFE_INTEGER;
+}
+function Ml(t, e) {
+  return t != null ? ot(t, e) : 0;
+}
+function vo(t, e, l, n, o) {
+  let i = !1, a = e.map((u, s) => {
+    var d, c, r, p;
+    let f = l.get(u.key) != null ? (d = l.get(u.key)) !== null && d !== void 0 ? d : "1fr" : (p = (r = (c = u.width) !== null && c !== void 0 ? c : u.defaultWidth) !== null && r !== void 0 ? r : n?.(s)) !== null && p !== void 0 ? p : "1fr", m = !1, h = 0, y = 0, b = 0;
+    bo(f) ? (h = ot(f, t), m = !0) : (y = go(f), y <= 0 && (m = !0));
+    var $, g;
+    let D = Ml((g = ($ = u.minWidth) !== null && $ !== void 0 ? $ : o?.(s)) !== null && g !== void 0 ? g : 0, t), v = Al(u.maxWidth, t), C = Math.max(D, Math.min(h, v));
+    return m ? b = C : h > C && (m = !0, b = C), m || (i = !0), {
+      frozen: m,
+      baseSize: h,
+      hypotheticalMainSize: C,
+      min: D,
+      max: v,
+      flex: y,
+      targetMainSize: b,
+      violation: 0
+    };
+  });
+  for (; i; ) {
+    let u = 0, s = 0;
+    a.forEach((r) => {
+      r.frozen ? u += r.targetMainSize : (u += r.baseSize, s += r.flex);
+    });
+    let d = t - u;
+    d > 0 && a.forEach((r) => {
+      if (!r.frozen) {
+        let p = r.flex / s;
+        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 yo(a);
+}
+function yo(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 $o {
+  /** 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, u;
+      return [
+        l,
+        (u = (a = n.props.defaultWidth) !== null && a !== void 0 ? a : (o = (i = this).getDefaultWidth) === null || o === void 0 ? void 0 : o.call(i, n)) !== null && u !== void 0 ? u : "1fr"
+      ];
+    }));
+  }
+  getColumnWidth(e) {
+    var l;
+    return (l = this.columnWidths.get(e)) !== null && l !== void 0 ? l : 0;
+  }
+  getColumnMinWidth(e) {
+    var l;
+    return (l = this.columnMinWidths.get(e)) !== null && l !== void 0 ? l : 0;
+  }
+  getColumnMaxWidth(e) {
+    var l;
+    return (l = this.columnMaxWidths.get(e)) !== null && l !== void 0 ? l : 0;
+  }
+  resizeColumnWidth(e, l, n, o) {
+    let i = this.columnWidths, a = !0, u = /* @__PURE__ */ new Map();
+    return o = Math.max(this.getColumnMinWidth(n), Math.min(this.getColumnMaxWidth(n), Math.floor(o))), e.columns.forEach((s) => {
+      var d, c;
+      s.key === n ? (u.set(s.key, o), a = !1) : a ? u.set(s.key, (d = i.get(s.key)) !== null && d !== void 0 ? d : 0) : u.set(s.key, (c = s.props.width) !== null && c !== void 0 ? c : l.get(s.key));
+    }), u;
+  }
+  buildColumnWidths(e, l, n) {
+    return this.columnWidths = /* @__PURE__ */ new Map(), this.columnMinWidths = /* @__PURE__ */ new Map(), this.columnMaxWidths = /* @__PURE__ */ new Map(), vo(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 u = l.columns[a].key, s = l.columns[a];
+      this.columnWidths.set(u, i);
+      var d;
+      this.columnMinWidths.set(u, Ml((d = s.props.minWidth) !== null && d !== void 0 ? d : this.getDefaultMinWidth(s), e)), this.columnMaxWidths.set(u, Al(s.props.maxWidth, e));
+    }), this.columnWidths;
+  }
+  constructor(e) {
+    this.columnWidths = /* @__PURE__ */ new Map(), this.columnMinWidths = /* @__PURE__ */ new Map(), this.columnMaxWidths = /* @__PURE__ */ new Map();
+    var l;
+    this.getDefaultWidth = (l = e?.getDefaultWidth) !== null && l !== void 0 ? l : () => "1fr";
+    var n;
+    this.getDefaultMinWidth = (n = e?.getDefaultMinWidth) !== null && n !== void 0 ? n : () => 75;
+  }
+}
+function xo(t, e) {
+  let { getDefaultWidth: l, getDefaultMinWidth: n, tableWidth: o = 0 } = t, [i, a] = q(null), u = N(() => new $o({
+    getDefaultWidth: l,
+    getDefaultMinWidth: n
+  }), [
+    l,
+    n
+  ]), [s, d] = N(() => u.splitColumnsIntoControlledAndUncontrolled(e.collection.columns), [
+    e.collection.columns,
+    u
+  ]), [c, r] = q(() => u.getInitialUncontrolledWidths(d)), [p, f] = q(e.collection.columns);
+  if (e.collection.columns !== p) {
+    if (e.collection.columns.length !== p.length || e.collection.columns.some((g, D) => g.key !== p[D].key)) {
+      let g = u.getInitialUncontrolledWidths(d);
+      r(g);
+    }
+    f(e.collection.columns);
+  }
+  let m = N(() => u.recombineColumns(e.collection.columns, c, d, s), [
+    e.collection.columns,
+    c,
+    d,
+    s,
+    u
+  ]), h = W((g) => {
+    a(g);
+  }, [
+    a
+  ]), y = W((g, D) => {
+    let v = u.resizeColumnWidth(e.collection, c, g, D), C = new Map(Array.from(d).map(([S]) => [
+      S,
+      v.get(S)
+    ]));
+    return C.set(g, D), r(C), v;
+  }, [
+    d,
+    r,
+    u,
+    e.collection,
+    c
+  ]), b = W(() => {
+    a(null);
+  }, [
+    a
+  ]), $ = N(() => u.buildColumnWidths(o, e.collection, m), [
+    o,
+    e.collection,
+    m,
+    u
+  ]);
+  return N(() => ({
+    resizingColumn: i,
+    updateResizedColumns: y,
+    startResize: h,
+    endResize: b,
+    getColumnWidth: (g) => u.getColumnWidth(g),
+    getColumnMinWidth: (g) => u.getColumnMinWidth(g),
+    getColumnMaxWidth: (g) => u.getColumnMaxWidth(g),
+    tableState: e,
+    columnWidths: $
+  }), [
+    u,
+    $,
+    i,
+    y,
+    h,
+    b,
+    e
+  ]);
+}
+function Do(t) {
+  let { collection: e, focusMode: l } = t, n = t.UNSAFE_selectionState || Kt(t), o = N(() => t.disabledKeys ? new Set(t.disabledKeys) : /* @__PURE__ */ new Set(), [
+    t.disabledKeys
+  ]), i = n.setFocusedKey;
+  n.setFocusedKey = (s, d) => {
+    if (l === "cell" && s != null) {
+      let m = e.getItem(s);
+      if (m?.type === "item") {
+        var c, r;
+        let h = L(m, e);
+        var p, f;
+        d === "last" ? s = (p = (c = ue(h)) === null || c === void 0 ? void 0 : c.key) !== null && p !== void 0 ? p : null : s = (f = (r = ae(h)) === null || r === void 0 ? void 0 : r.key) !== null && f !== void 0 ? f : null;
+      }
+    }
+    i(s, d);
+  };
+  let a = N(() => new Jl(e, n), [
+    e,
+    n
+  ]);
+  const u = M(null);
+  return de(() => {
+    if (n.focusedKey != null && u.current && !e.getItem(n.focusedKey)) {
+      const s = u.current.getItem(n.focusedKey), d = s?.parentKey != null && (s.type === "cell" || s.type === "rowheader" || s.type === "column") ? u.current.getItem(s.parentKey) : s;
+      if (!d) {
+        n.setFocusedKey(null);
+        return;
+      }
+      const c = u.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 ? [
+          ...L(m, e)
+        ] : [], y = m.hasChildNodes && d !== s && s && s.index < h.length ? h[s.index].key : m.key;
+        n.setFocusedKey(y);
+      } else n.setFocusedKey(null);
+    }
+    u.current = e;
+  }, [
+    e,
+    a,
+    n,
+    n.focusedKey
+  ]), {
+    collection: e,
+    disabledKeys: o,
+    isKeyboardNavigationDisabled: !1,
+    selectionManager: a
+  };
+}
+class Co {
+  *[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 v of r.childNodes) if (((y = v.props) === null || y === void 0 ? void 0 : y.colSpan) !== void 0) {
+          h = !0;
+          break;
+        }
+      }
+      for (let v of r.childNodes) {
+        if (v.type === "cell" && h) {
+          var b, $;
+          v.colspan = (b = v.props) === null || b === void 0 ? void 0 : b.colSpan, v.colSpan = ($ = v.props) === null || $ === void 0 ? void 0 : $.colSpan;
+          var g, D;
+          v.colIndex = m ? ((g = m.colIndex) !== null && g !== void 0 ? g : m.index) + ((D = m.colSpan) !== null && D !== void 0 ? D : 1) : v.index;
+        }
+        v.type === "cell" && v.parentKey == null && (v.parentKey = r.key), f.add(v.key), m ? (m.nextKey = v.key, v.prevKey = m.key) : v.prevKey = null, l(v), m = v;
+      }
+      if (m && (m.nextKey = null), p)
+        for (let v of p.childNodes) f.has(v.key) || n(v);
+    }, 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, u, s, 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: (u = p.type) !== null && u !== void 0 ? u : "row",
+        value: (s = p.value) !== null && s !== void 0 ? s : 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 Pl = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+let Je = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+for (; Pl === Je; ) Je = "row-header-column-" + Math.random().toString(36).slice(2);
+function Bl(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)), u = Array(a).fill(0).map(() => []), s = 0;
+  for (let c of l) {
+    let r = a - 1;
+    for (let p of c) {
+      if (p) {
+        let f = u[r], m = f.reduce((h, y) => {
+          var b;
+          return h + ((b = y.colSpan) !== null && b !== void 0 ? b : 1);
+        }, 0);
+        if (m < s) {
+          let h = {
+            type: "placeholder",
+            key: "placeholder-" + p.key,
+            colspan: s - m,
+            colSpan: s - m,
+            index: m,
+            value: null,
+            rendered: null,
+            level: 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 = s, f.push(p);
+      }
+      r--;
+    }
+    s++;
+  }
+  let d = 0;
+  for (let c of u) {
+    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 u.map((c, r) => ({
+    type: "headerrow",
+    key: "headerrow-" + r,
+    index: r,
+    value: null,
+    rendered: null,
+    level: 0,
+    hasChildNodes: !0,
+    childNodes: c,
+    textValue: ""
+  }));
+}
+class wo extends Co {
+  *[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 = ae(this.body.childNodes)) === null || e === void 0 ? void 0 : e.key) !== null && l !== void 0 ? l : null;
+  }
+  getLastKey() {
+    var e, l;
+    return (l = (e = ue(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: Pl,
+        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: Je,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isDragButtonCell: !0
+        }
+      };
+      a.unshift(r);
+    }
+    let u = [], s = /* @__PURE__ */ new Map(), d = (r) => {
+      switch (r.type) {
+        case "body":
+          i = r;
+          break;
+        case "column":
+          s.set(r.key, r), r.hasChildNodes || (a.push(r), r.props.isRowHeader && o.add(r.key));
+          break;
+        case "item":
+          u.push(r);
+          return;
+      }
+      for (let p of r.childNodes) d(p);
+    };
+    for (let r of e) d(r);
+    let c = Bl(s, a);
+    if (c.forEach((r, p) => u.splice(p, 0, r)), super({
+      columnCount: a.length,
+      items: u,
+      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 So = {
+  ascending: "descending",
+  descending: "ascending"
+};
+function ko(t) {
+  let [e, l] = q(!1), { selectionMode: n = "none", showSelectionCheckboxes: o, showDragButtons: i } = t, a = N(() => ({
+    showSelectionCheckboxes: o && n !== "none",
+    showDragButtons: i,
+    selectionMode: n,
+    columns: []
+  }), [
+    t.children,
+    o,
+    n,
+    i
+  ]), u = Ql(t, W((r) => new wo(r, null, a), [
+    a
+  ]), a), { disabledKeys: s, selectionManager: d } = Do({
+    ...t,
+    collection: u,
+    disabledBehavior: t.disabledBehavior || "selection"
+  });
+  var c;
+  return {
+    collection: u,
+    disabledKeys: s,
+    selectionManager: d,
+    showSelectionCheckboxes: t.showSelectionCheckboxes || !1,
+    sortDescriptor: (c = t.sortDescriptor) !== null && c !== void 0 ? c : null,
+    isKeyboardNavigationDisabled: u.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 ? So[t.sortDescriptor.direction] : "ascending")
+      });
+    }
+  };
+}
+function Eo(t, e) {
+  let l = N(() => e ? t.collection.filter(e) : t.collection, [
+    t.collection,
+    e
+  ]), n = t.selectionManager.withCollection(l);
+  return {
+    ...t,
+    collection: l,
+    selectionManager: n
+  };
+}
+function zo(t) {
+  return t && t.__esModule ? t.default : t;
+}
+class Ro extends sn {
+  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 u = a.lastChildKey;
+      if (u != null) {
+        let s = this.getItem(u);
+        var o, i;
+        let d = ((o = s.colIndex) !== null && o !== void 0 ? o : s.index) + ((i = s.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 = Bl(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 at(-1), this.body = new ut(-2), this.columnsDirty = !0;
+  }
+}
+const it = /* @__PURE__ */ me(null), To = /* @__PURE__ */ Oe(function(e, l) {
+  let n = Q(l), o = M(null), i = M(null), [a, u] = q(0);
+  Dt(() => {
+    let d = o.current;
+    for (; d && d !== n.current && !pn(d); ) d = d.parentElement;
+    i.current = d;
+  }, [
+    n
+  ]), fn({
+    ref: i,
+    box: "border-box",
+    onResize() {
+      var d, c;
+      u((c = (d = i.current) === null || d === void 0 ? void 0 : d.clientWidth) !== null && c !== void 0 ? c : 0);
+    }
+  }), Dt(() => {
+    var d, c;
+    u((c = (d = i.current) === null || d === void 0 ? void 0 : d.clientWidth) !== null && c !== void 0 ? c : 0);
+  }, []);
+  let s = N(() => ({
+    tableRef: o,
+    scrollRef: i,
+    tableWidth: a,
+    useTableColumnResizeState: xo,
+    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(it.Provider, {
+    value: s
+  }, e.children));
+}), Ao = /* @__PURE__ */ me(null), oe = /* @__PURE__ */ me(null), rt = /* @__PURE__ */ me(null), Mo = /* @__PURE__ */ Oe(function(e, l) {
+  var n;
+  [e, l] = It(e, l, Ao);
+  let o = Kt(e), { selectionBehavior: i, selectionMode: a, disallowEmptySelection: u } = o, s = !!(!((n = e.dragAndDropHooks) === null || n === void 0) && n.useDraggableCollectionState), d = N(() => ({
+    selectionBehavior: a === "none" ? null : i,
+    selectionMode: a,
+    disallowEmptySelection: u,
+    allowsDragging: s
+  }), [
+    i,
+    a,
+    u,
+    s
+  ]), c = /* @__PURE__ */ E.createElement(Nl.Provider, {
+    value: d
+  }, /* @__PURE__ */ E.createElement(Te, e));
+  return /* @__PURE__ */ E.createElement(an, {
+    content: c,
+    createCollection: () => new Ro()
+  }, (r) => /* @__PURE__ */ E.createElement(Po, {
+    props: e,
+    forwardedRef: l,
+    selectionState: o,
+    collection: r
+  }));
+});
+function Po({ props: t, forwardedRef: e, selectionState: l, collection: n }) {
+  [t, e] = It(t, e, $t);
+  let { shouldUseVirtualFocus: o, disallowTypeAhead: i, filter: a, ...u } = t, s = B(it);
+  e = Q(N(() => _l(e, s?.tableRef), [
+    e,
+    s?.tableRef
+  ]));
+  let d = ko({
+    ...u,
+    collection: n,
+    children: void 0,
+    UNSAFE_selectionState: l
+  }), c = Eo(d, a), { isVirtualized: r, layoutDelegate: p, dropTargetDelegate: f, CollectionRoot: m } = B(ee), { dragAndDropHooks: h } = t, { gridProps: y } = oo({
+    ...u,
+    layoutDelegate: p,
+    isVirtualized: r
+  }, c, e), b = c.selectionManager, $ = !!h?.useDraggableCollectionState, g = !!h?.useDroppableCollectionState, D = M($), v = M(g);
+  de(() => {
+    process.env.NODE_ENV !== "production" && (D.current !== $ && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), v.current !== g && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."));
+  }, [
+    $,
+    g
+  ]);
+  let C, S, P, T = !1, z = null, I = M(null);
+  if ($ && h) {
+    C = h.useDraggableCollectionState({
+      collection: c.collection,
+      selectionManager: b,
+      preview: h.renderDragPreview ? I : void 0
+    }), h.useDraggableCollection({}, C, e);
+    let k = h.DragPreview;
+    z = h.renderDragPreview ? /* @__PURE__ */ E.createElement(k, {
+      ref: I
+    }, h.renderDragPreview) : null;
+  }
+  if (g && h) {
+    S = h.useDroppableCollectionState({
+      collection: c.collection,
+      selectionManager: b
+    });
+    let k = new kn({
+      collection: c.collection,
+      disabledKeys: b.disabledKeys,
+      disabledBehavior: b.disabledBehavior,
+      ref: e,
+      layoutDelegate: p
+    }), w = h.dropTargetDelegate || f || new h.ListDropTargetDelegate(n.rows, e);
+    P = h.useDroppableCollection({
+      keyboardDelegate: k,
+      dropTargetDelegate: w
+    }, S, e), T = S.isDropTarget({
+      type: "root"
+    });
+  }
+  let { focusProps: H, isFocused: j, isFocusVisible: V } = De(), K = ce({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-Table",
+    values: {
+      isDropTarget: T,
+      isFocused: j,
+      isFocusVisible: V,
+      state: c
+    }
+  }), Y = !!($ && !C?.isDisabled), U = K.style, le = null;
+  s && (le = s.useTableColumnResizeState({
+    tableWidth: s.tableWidth
+  }, c), r || (U = {
+    ...U,
+    tableLayout: "fixed",
+    width: "fit-content"
+  }));
+  let pe = G("table"), ie = te(t, {
+    global: !0
+  });
+  var ne;
+  return /* @__PURE__ */ E.createElement(je, {
+    values: [
+      [
+        oe,
+        c
+      ],
+      [
+        rt,
+        le
+      ],
+      [
+        Ce,
+        {
+          dragAndDropHooks: h,
+          dragState: C,
+          dropState: S
+        }
+      ],
+      [
+        tn,
+        {
+          render: Wo
+        }
+      ],
+      [
+        $t,
+        null
+      ],
+      [
+        ql,
+        null
+      ]
+    ]
+  }, /* @__PURE__ */ E.createElement(xn, null, /* @__PURE__ */ E.createElement(pe, {
+    ...O(ie, K, y, H, P?.collectionProps),
+    style: U,
+    ref: e,
+    slot: t.slot || void 0,
+    onScroll: t.onScroll,
+    "data-allows-dragging": Y || void 0,
+    "data-drop-target": T || void 0,
+    "data-focused": j || void 0,
+    "data-focus-visible": V || void 0
+  }, /* @__PURE__ */ E.createElement(rn, null, /* @__PURE__ */ E.createElement(m, {
+    collection: c.collection,
+    scrollRef: (ne = s?.scrollRef) !== null && ne !== void 0 ? ne : e,
+    persistedKeys: ln(b, h, S)
+  })))), z);
+}
+function G(t) {
+  let { isVirtualized: e } = B(ee);
+  return e ? "div" : t;
+}
+const Nl = /* @__PURE__ */ me(null);
+function Kl() {
+  return B(Nl);
+}
+class at extends Ue {
+}
+at.type = "tableheader";
+const Bo = /* @__PURE__ */ _e(at, (t, e) => {
+  let l = B(oe).collection, n = un({
+    items: l.headerRows,
+    children: W((d) => {
+      switch (d.type) {
+        case "headerrow":
+          return /* @__PURE__ */ E.createElement(No, {
+            item: d
+          });
+        default:
+          throw new Error("Unsupported node type in TableHeader: " + d.type);
+      }
+    }, [])
+  }), o = G("thead"), { rowGroupProps: i } = Tl(), { hoverProps: a, isHovered: u } = Ae({
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), s = ce({
+    className: t.className,
+    style: t.style,
+    defaultClassName: "react-aria-TableHeader",
+    values: {
+      isHovered: u
+    }
+  });
+  return /* @__PURE__ */ E.createElement(o, {
+    ...O(te(t, {
+      global: !0
+    }), i, a),
+    ...s,
+    ref: e,
+    "data-hovered": u || void 0
+  }, n);
+}, (t) => /* @__PURE__ */ E.createElement(Te, {
+  dependencies: t.dependencies,
+  items: t.columns
+}, t.children));
+function No({ item: t }) {
+  let e = M(null), l = B(oe), { isVirtualized: n, CollectionBranch: o } = B(ee), { rowProps: i } = uo({
+    node: t,
+    isVirtualized: n
+  }, l, e), { checkboxProps: a } = po(l), u = G("tr");
+  return /* @__PURE__ */ E.createElement(u, {
+    ...i,
+    ref: e
+  }, /* @__PURE__ */ E.createElement(je, {
+    values: [
+      [
+        Bt,
+        {
+          slots: {
+            selection: a
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ E.createElement(o, {
+    collection: l.collection,
+    parent: t
+  })));
+}
+class Fl extends Ue {
+}
+Fl.type = "column";
+const Ko = /* @__PURE__ */ Vt(Fl, (t, e, l) => {
+  var n, o;
+  let i = Q(e), a = B(oe), { isVirtualized: u } = B(ee), { columnHeaderProps: s } = ro({
+    node: l,
+    isVirtualized: u
+  }, a, i), { isFocused: d, isFocusVisible: c, focusProps: r } = De(), p = B(rt), f = !1;
+  if (p) f = p.resizingColumn === l.key;
+  else if (process.env.NODE_ENV !== "production")
+    for (let D in [
+      "width",
+      "defaultWidth",
+      "minWidth",
+      "maxWidth"
+    ]) D in l.props && console.warn(`The ${D} 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 } = Ae({
+    isDisabled: !t.allowsSorting
+  }), y = ce({
+    ...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: (D) => {
+        a.sort(l.key, D);
+      }
+    }
+  }), b = y.style;
+  p && (b = {
+    ...b,
+    width: p.getColumnWidth(l.key)
+  });
+  let $ = G("th"), g = te(t, {
+    global: !0
+  });
+  return delete g.id, /* @__PURE__ */ E.createElement($, {
+    ...O(g, s, r, m),
+    ...y,
+    style: b,
+    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(je, {
+    values: [
+      [
+        Il,
+        {
+          column: l,
+          triggerRef: i
+        }
+      ],
+      [
+        ee,
+        Ft
+      ]
+    ]
+  }, y.children));
+}), Il = /* @__PURE__ */ me(null), Fo = /* @__PURE__ */ Oe(function(e, l) {
+  let n = B(rt);
+  if (!n) throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+  let o = Me(zo(nn), "react-aria-components"), { onResizeStart: i, onResize: a, onResizeEnd: u } = B(it), { column: s, triggerRef: d } = B(Il), c = M(null), { resizerProps: r, inputProps: p, isResizing: f } = ho({
+    column: s,
+    "aria-label": e["aria-label"] || o.format("tableResizer"),
+    onResizeStart: i,
+    onResize: a,
+    onResizeEnd: u,
+    triggerRef: d
+  }, n, c), { focusProps: m, isFocused: h, isFocusVisible: y } = De(), { hoverProps: b, isHovered: $ } = Ae(e), g = n.getColumnMinWidth(s.key) >= n.getColumnWidth(s.key), D = n.getColumnMaxWidth(s.key) <= n.getColumnWidth(s.key), { direction: v } = we(), C = "both";
+  g ? C = v === "rtl" ? "right" : "left" : D ? C = v === "rtl" ? "left" : "right" : C = "both";
+  let S = Q(l), [P, T] = q("");
+  de(() => {
+    if (!S.current) return;
+    let K = window.getComputedStyle(S.current);
+    T(K.cursor);
+  }, [
+    S,
+    C
+  ]);
+  let z = ce({
+    ...e,
+    defaultClassName: "react-aria-ColumnResizer",
+    values: {
+      isFocused: h,
+      isFocusVisible: y,
+      isResizing: f,
+      isHovered: $,
+      resizableDirection: C
+    }
+  }), [I, H] = q(!1), j = (K) => {
+    K.pointerType === "mouse" && H(!0);
+  };
+  !f && I && H(!1);
+  let V = te(e, {
+    global: !0
+  });
+  return /* @__PURE__ */ E.createElement("div", {
+    ref: S,
+    role: "presentation",
+    ...O(V, z, r, {
+      onPointerDown: j
+    }, b),
+    "data-hovered": $ || void 0,
+    "data-focused": h || void 0,
+    "data-focus-visible": y || void 0,
+    "data-resizing": f || void 0,
+    "data-resizable-direction": C
+  }, z.children, /* @__PURE__ */ E.createElement("input", {
+    ref: c,
+    ...O(p, m)
+  }), f && I && /* @__PURE__ */ mn.createPortal(/* @__PURE__ */ E.createElement("div", {
+    style: {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      bottom: 0,
+      right: 0,
+      cursor: P
+    }
+  }), document.body));
+});
+class ut extends dn {
+}
+ut.type = "tablebody";
+const Io = /* @__PURE__ */ _e(ut, (t, e) => {
+  let l = B(oe), { isVirtualized: n } = B(ee), o = l.collection, { CollectionBranch: i } = B(ee), { dragAndDropHooks: a, dropState: u } = B(Ce), s = !!a?.useDroppableCollectionState && !u?.isDisabled;
+  var d;
+  let c = s && !!u && ((d = u.isDropTarget({
+    type: "root"
+  })) !== null && d !== void 0 ? d : !1), r = o.size === 0, p = {
+    isDropTarget: c,
+    isEmpty: r
+  }, f = ce({
+    ...t,
+    id: void 0,
+    children: void 0,
+    defaultClassName: "react-aria-TableBody",
+    values: p
+  }), m, h = G("tr"), y = G("td"), b = o.columnCount;
+  if (r && t.renderEmptyState && l) {
+    let v = {}, C = {}, S = {};
+    n ? (C["aria-colspan"] = b, S = {
+      display: "contents"
+    }) : C.colSpan = b, m = /* @__PURE__ */ E.createElement(h, {
+      role: "row",
+      ...v,
+      style: S
+    }, /* @__PURE__ */ E.createElement(y, {
+      role: "rowheader",
+      ...C,
+      style: S
+    }, t.renderEmptyState(p)));
+  }
+  let { rowGroupProps: $ } = Tl(), g = G("tbody"), D = te(t, {
+    global: !0
+  });
+  return /* @__PURE__ */ E.createElement(g, {
+    ...O(D, f, $),
+    ref: e,
+    "data-empty": r || void 0
+  }, s && /* @__PURE__ */ E.createElement(Oo, null), /* @__PURE__ */ E.createElement(i, {
+    collection: o,
+    parent: o.body,
+    renderDropIndicator: en(a, u)
+  }), m);
+});
+class Vl extends Ue {
+  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;
+  }
+}
+Vl.type = "item";
+const Rt = /* @__PURE__ */ _e(Vl, (t, e, l) => {
+  let n = Q(e), o = B(oe), { dragAndDropHooks: i, dragState: a, dropState: u } = B(Ce), { isVirtualized: s, CollectionBranch: d } = B(ee), { rowProps: c, ...r } = ao({
+    node: l,
+    shouldSelectOnPressUp: !!a,
+    isVirtualized: s
+  }, o, n), { isFocused: p, isFocusVisible: f, focusProps: m } = De(), { isFocusVisible: h, focusProps: y } = De({
+    within: !0
+  }), { hoverProps: b, isHovered: $ } = Ae({
+    isDisabled: !r.allowsSelection && !r.hasAction,
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), { checkboxProps: g } = fo({
+    key: l.key
+  }, o), D;
+  a && i && (D = i.useDraggableItem({
+    key: l.key,
+    hasDragButton: !0
+  }, a));
+  let v, C = M(null), { visuallyHiddenProps: S } = Ge();
+  u && i && (v = i.useDropIndicator({
+    target: {
+      type: "item",
+      key: l.key,
+      dropPosition: "on"
+    }
+  }, u, C));
+  let P = M(null);
+  de(() => {
+    a && !P.current && process.env.NODE_ENV !== "production" && console.warn('Draggable items in a Table must contain a <Button slot="drag"> element so that keyboard and screen reader users can drag them.');
+  }, []);
+  let T = a && a.isDragging(l.key), { children: z, ...I } = t, H = ce({
+    ...I,
+    id: void 0,
+    defaultClassName: "react-aria-Row",
+    values: {
+      ...r,
+      isHovered: $,
+      isFocused: p,
+      isFocusVisible: f,
+      selectionMode: o.selectionManager.selectionMode,
+      selectionBehavior: o.selectionManager.selectionBehavior,
+      isDragging: T,
+      isDropTarget: v?.isDropTarget,
+      isFocusVisibleWithin: h,
+      id: l.key
+    }
+  }), j = G("tr"), V = G("td"), K = te(t, {
+    global: !0
+  });
+  return delete K.id, delete K.onClick, /* @__PURE__ */ E.createElement(E.Fragment, null, v && !v.isHidden && /* @__PURE__ */ E.createElement(j, {
+    role: "row",
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ E.createElement(V, {
+    role: "gridcell",
+    colSpan: o.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ E.createElement("div", {
+    role: "button",
+    ...S,
+    ...v.dropIndicatorProps,
+    ref: C
+  }))), /* @__PURE__ */ E.createElement(j, {
+    ...O(K, H, c, m, b, D?.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": T || void 0,
+    "data-drop-target": v?.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(je, {
+    values: [
+      [
+        Bt,
+        {
+          slots: {
+            [xt]: {},
+            selection: g
+          }
+        }
+      ],
+      [
+        Pt,
+        {
+          slots: {
+            [xt]: {},
+            drag: {
+              ...D?.dragButtonProps,
+              ref: P,
+              style: {
+                pointerEvents: "none"
+              }
+            }
+          }
+        }
+      ],
+      [
+        on,
+        {
+          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 Wl extends Ue {
+}
+Wl.type = "cell";
+const Vo = /* @__PURE__ */ Vt(Wl, (t, e, l) => {
+  let n = Q(e), o = B(oe), { dragState: i } = B(Ce), { isVirtualized: a } = B(ee);
+  l.column = o.collection.columns[l.index];
+  let { gridCellProps: u, isPressed: s } = so({
+    node: l,
+    shouldSelectOnPressUp: !!i,
+    isVirtualized: a
+  }, o, n), { isFocused: d, isFocusVisible: c, focusProps: r } = De(), { hoverProps: p, isHovered: f } = Ae({}), m = ce({
+    ...t,
+    id: void 0,
+    defaultClassName: "react-aria-Cell",
+    values: {
+      isFocused: d,
+      isFocusVisible: c,
+      isPressed: s,
+      isHovered: f,
+      id: l.key
+    }
+  }), h = G("td"), y = te(t, {
+    global: !0
+  });
+  return delete y.id, /* @__PURE__ */ E.createElement(h, {
+    ...O(y, m, u, r, p),
+    ref: n,
+    "data-focused": d || void 0,
+    "data-focus-visible": c || void 0,
+    "data-pressed": s || void 0
+  }, /* @__PURE__ */ E.createElement(ee.Provider, {
+    value: Ft
+  }, m.children));
+});
+function Wo(t, e) {
+  e = Q(e);
+  let { dragAndDropHooks: l, dropState: n } = B(Ce), o = M(null), { dropIndicatorProps: i, isHidden: a, isDropTarget: u } = l.useDropIndicator(t, n, o);
+  return a ? null : /* @__PURE__ */ E.createElement(Lo, {
+    ...t,
+    dropIndicatorProps: i,
+    isDropTarget: u,
+    buttonRef: o,
+    ref: e
+  });
+}
+function Ho(t, e) {
+  let { dropIndicatorProps: l, isDropTarget: n, buttonRef: o, ...i } = t, a = B(oe), { visuallyHiddenProps: u } = Ge(), s = ce({
+    ...i,
+    defaultClassName: "react-aria-DropIndicator",
+    values: {
+      isDropTarget: n
+    }
+  }), d = G("tr"), c = G("td");
+  return /* @__PURE__ */ E.createElement(d, {
+    ...te(t, {
+      global: !0
+    }),
+    ...s,
+    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", {
+    ...u,
+    role: "button",
+    ...l,
+    ref: o
+  }), s.children));
+}
+const Lo = /* @__PURE__ */ Oe(Ho);
+function Oo() {
+  let t = B(oe), { dragAndDropHooks: e, dropState: l } = B(Ce), n = M(null), { dropIndicatorProps: o } = e.useDropIndicator({
+    target: {
+      type: "root"
+    }
+  }, l, n), i = l.isDropTarget({
+    type: "root"
+  }), { visuallyHiddenProps: a } = Ge(), u = G("tr"), s = G("td");
+  return !i && o["aria-hidden"] ? null : /* @__PURE__ */ E.createElement(u, {
+    role: "row",
+    "aria-hidden": o["aria-hidden"],
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ E.createElement(s, {
+    role: "gridcell",
+    colSpan: t.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ E.createElement("div", {
+    role: "button",
+    ...a,
+    ...o,
+    ref: n
+  })));
+}
+const { withProvider: jo, withContext: Z } = /* @__PURE__ */ Xl({
+  key: "dataTable"
+}), Uo = /* @__PURE__ */ jo("div", "root"), Go = /* @__PURE__ */ Z("table", "table"), Yo = /* @__PURE__ */ Z("tr", "header"), Xo = /* @__PURE__ */ Z("th", "column"), qo = /* @__PURE__ */ Z("tbody", "body"), Tt = /* @__PURE__ */ Z("tr", "row"), Zo = /* @__PURE__ */ Z("td", "cell"), Jo = /* @__PURE__ */ Z("footer", "footer"), Qo = /* @__PURE__ */ Z("td", "selectionCell"), Hl = /* @__PURE__ */ Z("button", "expandButton"), _o = /* @__PURE__ */ Z("span", "nestedIcon"), ei = /* @__PURE__ */ Z("span", "headerSortIcon"), ti = /* @__PURE__ */ Z("div", "columnResizer"), Ye = /* @__PURE__ */ me(null);
+Ye.displayName = "DataTableContext";
+const fe = () => {
+  const t = B(
+    Ye
+  );
+  if (!t)
+    throw new Error("DataTable components must be used within DataTable.Root");
+  return t;
+}, xe = ({
+  ref: t,
+  children: e,
+  isDisabled: l,
+  ...n
+}) => {
+  const [o, i] = Se(n);
+  return /* @__PURE__ */ x(Zo, { asChild: !0, ...o, children: /* @__PURE__ */ x(Vo, { ref: t, ...i, children: (a) => /* @__PURE__ */ x(Pt.Provider, { value: { isDisabled: l }, children: typeof e == "function" ? e(a) : e }) }) });
+}, R = /* @__PURE__ */ Yl({
+  dataTable: {
+    id: "Nimbus.DataTable.dataTable",
+    description: "aria-label for the data table element",
+    defaultMessage: "Data table"
+  },
+  dataTableHeader: {
+    id: "Nimbus.DataTable.dataTableHeader",
+    description: "aria-label for the data table header element",
+    defaultMessage: "Data table header"
+  },
+  dataTableBody: {
+    id: "Nimbus.DataTable.dataTableBody",
+    description: "aria-label for the data table body element",
+    defaultMessage: "Data table body"
+  },
+  expandRows: {
+    id: "Nimbus.DataTable.expandRows",
+    description: "aria-label for the expand rows column header",
+    defaultMessage: "Expand rows"
+  },
+  pinRows: {
+    id: "Nimbus.DataTable.pinRows",
+    description: "aria-label for the pin rows column header",
+    defaultMessage: "Pin rows"
+  },
+  selectRow: {
+    id: "Nimbus.DataTable.selectRow",
+    description: "aria-label for the row selection checkbox",
+    defaultMessage: "Select row"
+  },
+  resizeColumn: {
+    id: "Nimbus.DataTable.resizeColumn",
+    description: "aria-label for the column resizer",
+    defaultMessage: "Resize column"
+  },
+  settings: {
+    id: "Nimbus.DataTable.settings",
+    description: "aria-label for the settings button in the data table manager",
+    defaultMessage: "Table settings"
+  },
+  visibleColumns: {
+    id: "Nimbus.DataTable.visibleColumns",
+    description: "title for the visible columns section in the data table manager",
+    defaultMessage: "Visible columns"
+  },
+  hiddenColumns: {
+    id: "Nimbus.DataTable.hiddenColumns",
+    description: "title for the hidden columns section in the data table manager",
+    defaultMessage: "Hidden columns"
+  },
+  noHiddenColumns: {
+    id: "Nimbus.DataTable.noHiddenColumns",
+    description: "message when there is no hidden columns in the data table manager",
+    defaultMessage: "No Hidden columns"
+  },
+  hiddenColumnsAriaLabel: {
+    id: "Nimbus.DataTable.hiddenColumnsAriaLabel",
+    description: "aria-label for the hidden columns list in the data table manager",
+    defaultMessage: "Hidden columns list"
+  },
+  visibleColumnsList: {
+    id: "Nimbus.DataTable.visibleColumnsList",
+    description: "title for the visible columns section in the data table manager",
+    defaultMessage: "Visible columns"
+  },
+  visibleColumnsAria: {
+    id: "Nimbus.DataTable.visibleColumnsAria",
+    description: "aria-label for the visible columns list in the data table manager",
+    defaultMessage: "Visible columns list"
+  },
+  hideColumn: {
+    id: "Nimbus.DataTable.hideColumn",
+    description: "aria-label for the hide column button in the data table manager",
+    defaultMessage: "Hide column"
+  },
+  reset: {
+    id: "Nimbus.DataTable.reset",
+    description: "aria-label for the reset columns button in the data table manager",
+    defaultMessage: "Reset columns"
+  },
+  layoutSettings: {
+    id: "Nimbus.DataTable.layoutSettings",
+    description: "title for the layout settings section in the data table manager",
+    defaultMessage: "Layout settings"
+  },
+  layoutSettingsAriaLabel: {
+    id: "Nimbus.DataTable.layoutSettingsAriaLabel",
+    description: "aria-label for the layout settings section in the data table manager",
+    defaultMessage: "Layout settings section"
+  },
+  textVisibility: {
+    id: "Nimbus.DataTable.textVisibility",
+    description: "title for the text visibility section in the data table manager layout",
+    defaultMessage: "Text visibility"
+  },
+  textVisibilityAriaLabel: {
+    id: "Nimbus.DataTable.textVisibilityAriaLabel",
+    description: "aria-label for the text visibility section in the data table manager layout",
+    defaultMessage: "Text visibility section"
+  },
+  fullText: {
+    id: "Nimbus.DataTable.fullText",
+    description: "title for the full text section in the data table manager layout",
+    defaultMessage: "Full text"
+  },
+  fullTextAriaLabel: {
+    id: "Nimbus.DataTable.fullTextAriaLabel",
+    description: "aria-label for the full text section in the data table manager layout",
+    defaultMessage: "Full text section"
+  },
+  TextPreviews: {
+    id: "Nimbus.DataTable.textPreviews",
+    description: "title for the text previews section in the data table manager layout",
+    defaultMessage: "Text previews"
+  },
+  TextPreviewsAriaLabel: {
+    id: "Nimbus.DataTable.textPreviewsAriaLabel",
+    description: "aria-label for the text previews section in the data table manager layout",
+    defaultMessage: "Text previews section"
+  },
+  RowDensity: {
+    id: "Nimbus.DataTable.rowDensity",
+    description: "title for the row density section in the data table manager layout",
+    defaultMessage: "Row density"
+  },
+  RowDensityAriaLabel: {
+    id: "Nimbus.DataTable.rowDensityAriaLabel",
+    description: "aria-label for the row density section in the data table manager layout",
+    defaultMessage: "Row density section"
+  },
+  comfortable: {
+    id: "Nimbus.DataTable.comfortable",
+    description: "title for the comfortable togglebutton in the data table manager layout",
+    defaultMessage: "Comfortable"
+  },
+  comfortableAriaLabel: {
+    id: "Nimbus.DataTable.comfortableAriaLabel",
+    description: "aria-label for the comfortable togglebutton in the data table manager layout",
+    defaultMessage: "Comfortable section"
+  },
+  compact: {
+    id: "Nimbus.DataTable.compact",
+    description: "title for the compact togglebutton in the data table manager layout",
+    defaultMessage: "Compact"
+  },
+  compactAriaLabel: {
+    id: "Nimbus.DataTable.compactAriaLabel",
+    description: "aria-label for the compact togglebutton in the data table manager layout",
+    defaultMessage: "Compact section"
+  },
+  searchHiddenColumns: {
+    id: "Nimbus.DataTable.searchHiddenColumns",
+    description: "placeholder for the search input in the hidden columns section in the data table manager",
+    defaultMessage: "Search..."
+  }
+});
+function Qe(t) {
+  return t.target?.closest(
+    'button, input, [role="button"], [role="checkbox"], [slot="selection"], [data-slot="selection"]'
+  );
+}
+function li(t) {
+  return t.target?.closest(
+    '[slot="selection"], [data-slot="selection"], [role="checkbox"]'
+  );
+}
+function At(t) {
+  const e = Qe(t), l = li(t);
+  (!e || e && !l) && t.stopPropagation();
+}
+const st = ({
+  row: t,
+  ref: e,
+  ...l
+}) => {
+  const n = he(), {
+    activeColumns: o,
+    search: i,
+    expanded: a,
+    toggleExpand: u,
+    nestedKey: s,
+    disabledKeys: d,
+    showExpandColumn: c,
+    showSelectionColumn: r,
+    isTruncated: p,
+    onRowClick: f,
+    onRowAction: m,
+    pinnedRows: h,
+    togglePin: y,
+    sortedRows: b
+  } = fe(), [$, g] = Se(l), v = ((w) => d ? d === "all" || t.isDisabled ? !0 : d.has(w) : !1)(t.id), C = M(null), S = W(
+    (w) => {
+      if (!f) return;
+      const F = Qe(w), re = window.getSelection()?.toString() !== void 0 && window.getSelection().toString().length > 0;
+      !F && !re && (C.current && window.clearTimeout(C.current), C.current = window.setTimeout(() => {
+        v ? m && m(t, "click") : f(t), C.current = null;
+      }, 300));
+    },
+    [f, m, t, v]
+  ), P = W((w) => {
+    Qe(w) || C.current && (window.clearTimeout(C.current), C.current = null);
+  }, []), T = M({
+    count: 0,
+    node: void 0
+  }), z = W(
+    (w) => {
+      T.current.count += 1, T.current.count === 1 && w && (T.current.node = w, w.addEventListener(
+        // Use pointerdown event in order to capture event before it bubbles to react-aria's onPress handler
+        "pointerdown",
+        At,
+        {
+          capture: !0
+        }
+      ), w.addEventListener("mouseup", S, { capture: !0 }), w.addEventListener("dblclick", P, {
+        capture: !0
+      }));
+    },
+    [S, P]
+  );
+  de(() => () => {
+    C.current && (window.clearTimeout(C.current), C.current = null), T.current.count >= 1 && T.current.node && (T.current.node.removeEventListener(
+      "pointerdown",
+      At
+    ), T.current.node.removeEventListener("mouseup", S), T.current.node.removeEventListener(
+      "dblclick",
+      P
+    ));
+  }, [S, P]);
+  const I = Re(e, z), { selectionBehavior: H } = Kl(), j = s && t[s] && (Array.isArray(t[s]) ? t[s].length > 0 : !0), V = a[t.id], K = h.has(t.id), Y = b.filter((w) => h.has(w.id)).map((w) => w.id), U = K ? Y.indexOf(t.id) : -1, le = U === 0, pe = U === Y.length - 1, ie = Y.length === 1 && K, ne = () => K ? ie ? "data-table-row-pinned-single" : le ? "data-table-row-pinned-first" : pe ? "data-table-row-pinned-last" : "" : "", k = (w) => i && typeof w == "string" ? /* @__PURE__ */ x(Mn, { query: i, ignoreCase: !0, matchAll: !0, children: w }) : w;
+  return /* @__PURE__ */ A(We, { children: [
+    /* @__PURE__ */ x(Tt, { asChild: !0, ...$, children: /* @__PURE__ */ A(
+      Rt,
+      {
+        isDisabled: v,
+        columns: o,
+        ref: I,
+        id: t.id,
+        className: `data-table-row ${v ? "data-table-row-disabled" : ""} ${K ? `data-table-row-pinned ${ne()}` : ""}`,
+        ...g,
+        dependencies: [V, i, p],
+        children: [
+          H === "toggle" && /* @__PURE__ */ x(
+            xe,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "selection",
+              isDisabled: v,
+              children: /* @__PURE__ */ x(
+                se,
+                {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  w: "100%",
+                  h: "100%",
+                  children: /* @__PURE__ */ x(
+                    Lt,
+                    {
+                      name: "select-row",
+                      slot: "selection",
+                      "aria-label": n.formatMessage(R.selectRow)
+                    }
+                  )
+                }
+              )
+            }
+          ),
+          c && /* @__PURE__ */ x(
+            xe,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "expand",
+              isDisabled: v,
+              children: j ? /* @__PURE__ */ x(
+                Hl,
+                {
+                  w: "100%",
+                  h: "100%",
+                  cursor: "pointer",
+                  "aria-label": V ? "Collapse" : "Expand",
+                  onClick: (w) => {
+                    w.stopPropagation(), u(t.id);
+                  },
+                  children: V ? /* @__PURE__ */ x(Pn, {}) : /* @__PURE__ */ x(Bn, {})
+                }
+              ) : null
+            }
+          ),
+          /* @__PURE__ */ x(Te, { items: o, children: (w) => {
+            const F = w.accessor(t);
+            return /* @__PURE__ */ x(xe, { isDisabled: v, children: /* @__PURE__ */ x(
+              se,
+              {
+                className: p ? "truncated-cell" : "",
+                "data-truncated": p ? "true" : "false",
+                display: "inline-block",
+                h: "100%",
+                minW: "0",
+                maxW: "100%",
+                position: "relative",
+                overflow: "hidden",
+                cursor: v ? "not-allowed" : "text",
+                children: w.render ? w.render({
+                  value: k(F),
+                  row: t,
+                  column: w
+                }) : k(F)
+              }
+            ) }, w.id);
+          } }),
+          /* @__PURE__ */ x(
+            xe,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "pin-row-cell",
+              isDisabled: v,
+              children: /* @__PURE__ */ x(
+                se,
+                {
+                  "data-slot": K ? "nimbus-table-cell-pin-button-pinned" : "nimbus-table-cell-pin-button",
+                  children: /* @__PURE__ */ A(Le.Root, { children: [
+                    /* @__PURE__ */ x(
+                      Ot,
+                      {
+                        size: "2xs",
+                        variant: "ghost",
+                        "aria-label": K ? "Unpin row" : "Pin row",
+                        colorPalette: "primary",
+                        onClick: (w) => {
+                          w.stopPropagation(), y(t.id);
+                        },
+                        children: /* @__PURE__ */ x(Nn, {})
+                      },
+                      "pin-btn"
+                    ),
+                    /* @__PURE__ */ x(Le.Content, { placement: "top", children: K ? "Unpin row" : "Pin row" })
+                  ] })
+                }
+              )
+            }
+          )
+        ]
+      }
+    ) }),
+    c && /* @__PURE__ */ x(Tt, { ...$, asChild: !0, children: /* @__PURE__ */ x(
+      Rt,
+      {
+        "data-nested-row-expanded": V ? "true" : "false",
+        dependencies: [V],
+        children: /* @__PURE__ */ x(
+          xe,
+          {
+            isDisabled: v,
+            colSpan: o.length + (c ? 1 : 0) + (r ? 1 : 0) + 1,
+            "data-nested-cell": !0,
+            children: V ? s && Array.isArray(t[s]) ? `${t[s].length} nested items` : s && t[s] : null
+          }
+        )
+      }
+    ) })
+  ] });
+};
+st.displayName = "DataTable.Row";
+const ni = () => /* @__PURE__ */ x(se, { w: "100%", p: "200", children: "No Data" }), dt = ({
+  ref: t,
+  ...e
+}) => {
+  const { sortedRows: l, activeColumns: n, renderEmptyState: o } = fe(), [i, a] = Se(e);
+  return /* @__PURE__ */ x(qo, { asChild: !0, ...i, children: /* @__PURE__ */ x(
+    Io,
+    {
+      ref: t,
+      items: l,
+      dependencies: [n],
+      renderEmptyState: o ?? ni,
+      ...a,
+      children: (u) => /* @__PURE__ */ x(st, { row: u }, u.id)
+    }
+  ) });
+};
+dt.displayName = "DataTable.Body";
+const ke = ({
+  children: t,
+  ref: e,
+  column: l,
+  isInternalColumn: n,
+  width: o,
+  minWidth: i,
+  maxWidth: a,
+  ...u
+}) => {
+  const s = he(), { sortDescriptor: d, isResizable: c } = fe(), r = d?.column === l?.id, p = l?.isResizable !== void 0 ? l?.isResizable : c, [f, m] = Se(u);
+  return /* @__PURE__ */ x(Xo, { ...f, asChild: !0, children: /* @__PURE__ */ x(
+    Ko,
+    {
+      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(
+          Yn,
+          {
+            tabIndex: p || y ? -1 : 0,
+            className: "nimbus-data-table__column-container",
+            children: [
+              /* @__PURE__ */ x(
+                jt,
+                {
+                  orientation: "vertical",
+                  className: "data-table-column-divider"
+                }
+              ),
+              typeof t == "function" ? t(h) : t,
+              y && /* @__PURE__ */ x(
+                ei,
+                {
+                  "aria-hidden": "true",
+                  "data-sort-active": r,
+                  "data-sort-direction": r ? d?.direction : "none",
+                  children: /* @__PURE__ */ x(Kn, {})
+                }
+              ),
+              p && /* @__PURE__ */ x(
+                Fo,
+                {
+                  "aria-label": s.formatMessage(R.resizeColumn),
+                  children: ({ isResizing: b, isFocused: $, isHovered: g }) => /* @__PURE__ */ x(
+                    ti,
+                    {
+                      "data-resizing": b,
+                      "data-focused": $,
+                      "data-hovered": g
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        );
+      }
+    }
+  ) });
+}, ct = function({
+  ref: e,
+  children: l,
+  ...n
+}) {
+  const o = M(null), i = Q(Re(o, e));
+  return /* @__PURE__ */ x(Jo, { ref: i, ...n, children: l });
+};
+ct.displayName = "DataTable.Footer";
+const ft = ({
+  ref: t,
+  ...e
+}) => {
+  const l = he(), { activeColumns: n, allowsSorting: o, maxHeight: i, showExpandColumn: a } = fe(), { selectionBehavior: u, selectionMode: s } = Kl(), [d, c] = Se(e);
+  return /* @__PURE__ */ x(Yo, { ...d, asChild: !0, children: /* @__PURE__ */ A(
+    Bo,
+    {
+      ref: t,
+      className: "data-table-header",
+      ...i && { "data-sticky": !0 },
+      columns: n,
+      ...c,
+      children: [
+        u === "toggle" && /* @__PURE__ */ x(
+          ke,
+          {
+            id: "selection",
+            className: "selection-column-header",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            children: s === "multiple" && /* @__PURE__ */ x(Lt, { slot: "selection" })
+          }
+        ),
+        a && /* @__PURE__ */ x(
+          ke,
+          {
+            className: "expand-column-header",
+            maxWidth: u === "toggle" ? 24 : 72,
+            minWidth: u === "toggle" ? 24 : 72,
+            allowsSorting: !1,
+            "aria-label": l.formatMessage(R.expandRows),
+            isInternalColumn: !0,
+            children: /* @__PURE__ */ x(St, { children: l.formatMessage(R.expandRows) })
+          }
+        ),
+        /* @__PURE__ */ x(Te, { items: n, children: (r) => /* @__PURE__ */ A(
+          ke,
+          {
+            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(se, { as: "span", ml: "200", children: r.headerIcon })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ x(
+          ke,
+          {
+            className: "pin-rows-column-header",
+            id: "pin-rows",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            "aria-label": l.formatMessage(R.pinRows),
+            children: /* @__PURE__ */ x(St, { children: l.formatMessage(R.pinRows) })
+          }
+        )
+      ]
+    }
+  ) });
+};
+ft.displayName = "DataTable.Header";
+function Ll(t, e, l, n) {
+  if (!e) return t;
+  const o = e.toLowerCase();
+  return t.map((i) => {
+    const a = l.some((u) => {
+      const s = u.accessor(i);
+      return typeof s == "string" && s.toLowerCase().includes(o);
+    });
+    if (n && i[n]) {
+      let u = i[n];
+      if (Array.isArray(i[n])) {
+        if (u = Ll(
+          i[n],
+          e,
+          l,
+          n
+        ), a || u && Array.isArray(u) && u.length > 0)
+          return { ...i, [n]: u };
+      } else if (a)
+        return { ...i, [n]: u };
+      return null;
+    } else
+      return a ? i : null;
+  }).filter(Boolean);
+}
+function Ol(t, e, l, n, o) {
+  const i = [], a = [];
+  t.forEach((d) => {
+    o?.has(d.id) ? i.push(d) : a.push(d);
+  });
+  let u = a;
+  if (e) {
+    const d = l.find((c) => c.id === e.column);
+    d && (u = [...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, ...u].map((d) => !n || !d[n] ? d : {
+    ...d,
+    [n]: Array.isArray(d[n]) ? Ol(
+      d[n],
+      e,
+      l,
+      n,
+      o
+    ) : d[n]
+  });
+}
+function jl(t, e) {
+  return e ? t.some(
+    (l) => l[e] && (Array.isArray(l[e]) ? l[e].length > 0 : !0) || Array.isArray(l[e]) && jl(l[e], e)
+  ) : !1;
+}
+const pt = function(e) {
+  const {
+    ref: l,
+    columns: n = [],
+    rows: o = [],
+    visibleColumns: i,
+    search: a,
+    sortDescriptor: u,
+    defaultSortDescriptor: s,
+    onSortChange: d,
+    selectedKeys: c,
+    defaultSelectedKeys: r,
+    onSelectionChange: p,
+    selectionMode: f = "none",
+    disallowEmptySelection: m = !1,
+    allowsSorting: h = !1,
+    maxHeight: y,
+    isTruncated: b = !1,
+    density: $ = "default",
+    nestedKey: g,
+    onRowClick: D,
+    onDetailsClick: v,
+    disabledKeys: C,
+    onRowAction: S,
+    isResizable: P,
+    pinnedRows: T,
+    defaultPinnedRows: z,
+    onPinToggle: I,
+    onColumnsChange: H,
+    onSettingsChange: j,
+    children: V,
+    ...K
+  } = e, Y = M(null), U = Q(Re(Y, l)), [le, pe] = q(s), [ie, ne] = q({}), [k, w] = q(
+    () => z || /* @__PURE__ */ new Set()
+  ), F = u ?? le, re = T ?? k, be = N(() => {
+    if (!i)
+      return n;
+    const X = new Map(n.map((J) => [J.id, J]));
+    return i.map((J) => X.get(J)).filter((J) => J !== void 0);
+  }, [n, i]), Be = N(
+    () => a ? Ll(o, a, be, g) : o,
+    [o, a, be, g]
+  ), Xe = N(
+    () => Ol(
+      Be,
+      F,
+      be,
+      g,
+      re
+    ),
+    [Be, F, be, g, re]
+  ), ht = jl(Xe, g), bt = f !== "none", gt = W(
+    (X) => ne((J) => ({ ...J, [X]: !J[X] })),
+    []
+  ), vt = W(
+    (X) => {
+      I ? I(X) : w((J) => {
+        const Ne = new Set(J);
+        return Ne.has(X) ? Ne.delete(X) : Ne.add(X), Ne;
+      });
+    },
+    [I]
+  ), yt = W(
+    (X) => {
+      d ? d(X) : pe(X);
+    },
+    [d]
+  ), Gl = N(
+    () => ({
+      columns: n,
+      rows: o,
+      visibleColumns: i,
+      search: a,
+      sortDescriptor: F,
+      selectedKeys: c,
+      defaultSelectedKeys: r,
+      expanded: ie,
+      allowsSorting: h,
+      selectionMode: f,
+      disallowEmptySelection: m,
+      maxHeight: y,
+      isTruncated: b,
+      density: $,
+      nestedKey: g,
+      onSortChange: yt,
+      onSelectionChange: p,
+      onRowClick: D,
+      onDetailsClick: v,
+      toggleExpand: gt,
+      activeColumns: be,
+      filteredRows: Be,
+      sortedRows: Xe,
+      showExpandColumn: ht,
+      showSelectionColumn: bt,
+      isResizable: P,
+      disabledKeys: C,
+      onRowAction: S,
+      pinnedRows: re,
+      onPinToggle: I,
+      togglePin: vt,
+      onColumnsChange: H,
+      onSettingsChange: j
+    }),
+    [
+      n,
+      o,
+      i,
+      a,
+      F,
+      c,
+      r,
+      ie,
+      h,
+      f,
+      m,
+      y,
+      b,
+      $,
+      g,
+      yt,
+      p,
+      D,
+      v,
+      gt,
+      be,
+      Be,
+      Xe,
+      ht,
+      bt,
+      P,
+      C,
+      S,
+      re,
+      I,
+      vt,
+      H,
+      j
+    ]
+  );
+  return /* @__PURE__ */ x(
+    Uo,
+    {
+      ref: U,
+      truncated: b,
+      density: $,
+      maxH: y,
+      ...K,
+      asChild: !0,
+      children: /* @__PURE__ */ x(To, { children: /* @__PURE__ */ x(
+        Ye.Provider,
+        {
+          value: Gl,
+          children: V
+        }
+      ) })
+    }
+  );
+};
+pt.displayName = "DataTableRoot";
+const mt = function({
+  ref: e,
+  children: l,
+  ...n
+}) {
+  const o = M(null), i = Q(Re(o, e)), {
+    sortDescriptor: a,
+    onSortChange: u,
+    selectionMode: s,
+    onSelectionChange: d,
+    selectedKeys: c,
+    defaultSelectedKeys: r,
+    disallowEmptySelection: p,
+    disabledKeys: f
+  } = fe(), [m, h] = Se(n), y = a ? {
+    column: a.column,
+    direction: a.direction
+  } : void 0;
+  return /* @__PURE__ */ x(Go, { ...m, asChild: !0, children: /* @__PURE__ */ x(
+    Mo,
+    {
+      ref: i,
+      sortDescriptor: y,
+      onSortChange: ($) => {
+        $ && u && u({
+          column: String($.column),
+          direction: $.direction
+        });
+      },
+      selectedKeys: c,
+      defaultSelectedKeys: r,
+      onSelectionChange: d,
+      selectionMode: s,
+      disallowEmptySelection: p,
+      disabledKeys: f,
+      disabledBehavior: "all",
+      ...h,
+      children: l
+    }
+  ) });
+};
+mt.displayName = "DataTable.Table";
+function oi(t) {
+  return "onRemoveItem" in t && typeof t.onRemoveItem == "function";
+}
+const ii = ({
+  hiddenItems: t,
+  visibleItems: e,
+  handleVisibleColumnsUpdate: l,
+  handleResetColumns: n
+}) => {
+  const [o, i] = q(""), { formatMessage: a } = he();
+  if (!t || !e)
+    return null;
+  const u = N(() => t.filter(
+    (r) => r.label?.toString().toLowerCase().includes(o.toLowerCase())
+  ), [t, o]), s = (r) => {
+    i(r);
+  }, d = W(
+    (r) => {
+      const p = new Set(t.map((b) => b.id)), f = new Set(
+        r.map((b) => b.id)
+      ), m = t.filter(
+        (b) => !f.has(b.id)
+      ), h = r.filter(
+        (b) => !p.has(b.id)
+      );
+      let y = [...e];
+      if (m.length > 0 && (y = [...y, ...m]), h.length > 0) {
+        const b = new Set(h.map(($) => $.id));
+        y = y.filter(
+          ($) => !b.has($.id)
+        );
+      }
+      l(y);
+    },
+    [t, e, l]
+  ), c = W(
+    (r) => {
+      l(r);
+    },
+    [l]
+  );
+  return /* @__PURE__ */ A(Ie, { mt: "800", children: [
+    /* @__PURE__ */ A($e, { gap: "400", width: "100%", columns: 2, children: [
+      /* @__PURE__ */ A(se, { children: [
+        /* @__PURE__ */ A(Ie, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(Fn, {}),
+          /* @__PURE__ */ x(ze, { fontWeight: "700", fontSize: "sm", w: "full", children: a(R.hiddenColumns) })
+        ] }),
+        /* @__PURE__ */ A(
+          Ie,
+          {
+            colorPalette: "primary",
+            border: "{sizes.25} solid",
+            borderColor: "colorPalette.3",
+            borderRadius: "200",
+            gap: "200",
+            p: "300",
+            h: "lg",
+            children: [
+              /* @__PURE__ */ x(
+                Xn,
+                {
+                  w: "full",
+                  size: "sm",
+                  variant: "ghost",
+                  placeholder: a(R.searchHiddenColumns),
+                  "aria-label": a(R.searchHiddenColumns),
+                  onChange: s,
+                  value: o,
+                  "data-testid": "search-hidden-columns"
+                }
+              ),
+              /* @__PURE__ */ x(
+                jt,
+                {
+                  colorPalette: "primary",
+                  border: "{sizes.25} solid",
+                  borderColor: "colorPalette.3"
+                }
+              ),
+              /* @__PURE__ */ x(
+                Fe.Root,
+                {
+                  border: "none",
+                  borderColor: "none",
+                  h: "full",
+                  overflowY: "auto",
+                  items: u,
+                  onUpdateItems: d,
+                  "aria-label": a(R.hiddenColumnsAriaLabel),
+                  "data-testid": "hidden-columns-list",
+                  renderEmptyState: /* @__PURE__ */ x(ze, { fontSize: "sm", color: "gray.9", children: a(R.noHiddenColumns) }),
+                  children: (r) => /* @__PURE__ */ x(
+                    Fe.Item,
+                    {
+                      py: "100",
+                      id: r.id,
+                      "aria-label": r.label?.toString() ?? r.id,
+                      children: r.label
+                    },
+                    r.id
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ A(se, { children: [
+        /* @__PURE__ */ A(Ie, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(In, {}),
+          /* @__PURE__ */ x(ze, { fontWeight: "700", fontSize: "sm", children: a(R.visibleColumnsList) })
+        ] }),
+        /* @__PURE__ */ x(
+          Fe.Root,
+          {
+            removableItems: !0,
+            p: "300",
+            h: "lg",
+            overflowY: "auto",
+            items: e,
+            onUpdateItems: c,
+            "aria-label": a(R.visibleColumnsAria),
+            "data-testid": "visible-columns-list",
+            children: (r) => /* @__PURE__ */ x(
+              Fe.Item,
+              {
+                py: "100",
+                id: r.id,
+                onRemoveItem: oi(r) ? r.onRemoveItem : void 0,
+                "aria-label": r.label?.toString() ?? r.id,
+                children: r.label
+              },
+              r.id
+            )
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ x(se, { children: /* @__PURE__ */ A(
+      qn,
+      {
+        variant: "ghost",
+        tone: "primary",
+        size: "xs",
+        onClick: n,
+        "aria-label": a(R.reset),
+        children: [
+          /* @__PURE__ */ x(Vn, {}),
+          a(R.reset)
+        ]
+      }
+    ) })
+  ] });
+}, Mt = {
+  TOGGLE_TEXT_VISIBILITY: "toggleTextVisibility",
+  TOGGLE_ROW_DENSITY: "toggleRowDensity"
+}, ri = ({
+  onSettingsChange: t
+}) => {
+  const { formatMessage: e } = he(), l = fe(), n = l.isTruncated ?? !1, o = l.density === "condensed" ? "compact" : "comfortable", i = (u) => {
+    Array.from(u)[0] && t?.(Mt.TOGGLE_TEXT_VISIBILITY);
+  }, a = (u) => {
+    Array.from(u)[0] && t?.(Mt.TOGGLE_ROW_DENSITY);
+  };
+  return /* @__PURE__ */ A(
+    $e,
+    {
+      templateColumns: "repeat(4, 1fr)",
+      columnGap: "400",
+      rowGap: "600",
+      mt: "800",
+      alignItems: "center",
+      children: [
+        /* @__PURE__ */ x($e.Item, { colSpan: 1, children: /* @__PURE__ */ x(ze, { fontWeight: "500", children: e(R.textVisibility) }) }),
+        /* @__PURE__ */ x($e.Item, { colSpan: 3, children: /* @__PURE__ */ x(kt, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Et.Root,
+          {
+            w: "full",
+            selectedKeys: n ? ["preview"] : ["full"],
+            onSelectionChange: i,
+            "aria-label": e(R.textVisibilityAriaLabel),
+            children: [
+              /* @__PURE__ */ A(
+                Ve,
+                {
+                  id: "full",
+                  size: "xs",
+                  "aria-label": e(R.fullText),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(Wn, {}),
+                    e(R.fullText)
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                Ve,
+                {
+                  id: "preview",
+                  size: "xs",
+                  "aria-label": e(R.TextPreviews),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(Hn, {}),
+                    e(R.TextPreviews)
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) }),
+        /* @__PURE__ */ x($e.Item, { colSpan: 1, children: /* @__PURE__ */ x(ze, { fontWeight: "500", children: e(R.RowDensity) }) }),
+        /* @__PURE__ */ x($e.Item, { colSpan: 3, children: /* @__PURE__ */ x(kt, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ A(
+          Et.Root,
+          {
+            w: "full",
+            tone: "primary",
+            selectedKeys: [o],
+            onSelectionChange: a,
+            "aria-label": e(R.RowDensityAriaLabel),
+            children: [
+              /* @__PURE__ */ A(
+                Ve,
+                {
+                  id: "comfortable",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e(R.comfortable),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(Ln, {}),
+                    e(R.comfortable)
+                  ]
+                }
+              ),
+              /* @__PURE__ */ A(
+                Ve,
+                {
+                  id: "compact",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e(R.compact),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(On, {}),
+                    e(R.compact)
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) })
+      ]
+    }
+  );
+}, Ul = () => {
+  const [t, e] = q(!1), l = fe(), { formatMessage: n } = he(), { columns: o, visibleColumns: i, onColumnsChange: a, onSettingsChange: u } = l, s = o.filter(
+    (b) => !i?.includes(b.id)
+  ), d = M(o);
+  de(() => {
+    d.current = o;
+  }, [o]);
+  const c = M(o), r = M(i), p = M(i || []);
+  if (!i || !s)
+    return null;
+  const f = N(() => (b) => {
+    const $ = b.map((C) => C.id);
+    if (!($.length !== p.current.length || $.some(
+      (C, S) => C !== p.current[S]
+    )))
+      return;
+    const D = new Map(d.current.map((C) => [C.id, C])), v = b.map((C) => D.get(C.id)).filter(
+      (C) => C !== void 0
+    );
+    p.current = $, a && a(v);
+  }, []), m = N(() => o.filter((b) => !i?.includes(b.id)).map((b) => ({
+    key: b.id,
+    id: b.id,
+    label: b.header
+  })), [i, o]), h = N(() => {
+    if (!i || i.length === 0)
+      return [];
+    const b = new Map(o.map(($) => [$.id, $]));
+    return i.map(($) => {
+      const g = b.get($);
+      return g ? {
+        key: g.id,
+        id: g.id,
+        label: g.header
+      } : null;
+    }).filter(($) => $ !== null);
+  }, [o, i]), y = W(() => {
+    if (a) {
+      const b = r.current;
+      if (b && b.length > 0) {
+        const $ = new Map(
+          c.current.map((D) => [D.id, D])
+        ), g = b.map((D) => $.get(D)).filter(
+          (D) => D !== void 0
+        );
+        p.current = b, a(g);
+      } else
+        p.current = c.current.map(
+          ($) => $.id
+        ), a(c.current);
+    }
+  }, [a]);
+  return /* @__PURE__ */ A(We, { children: [
+    /* @__PURE__ */ A(Le.Root, { children: [
+      /* @__PURE__ */ x(Le.Content, { placement: "top", children: n(R.settings) }),
+      /* @__PURE__ */ x(
+        Ot,
+        {
+          variant: "ghost",
+          tone: "primary",
+          size: "xs",
+          "aria-label": n(R.settings),
+          onClick: () => e(!0),
+          children: /* @__PURE__ */ x(jn, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ x(
+      ye.Root,
+      {
+        isOpen: t,
+        onOpenChange: e,
+        placement: "right",
+        "data-testid": "data-table-manager-drawer",
+        children: /* @__PURE__ */ A(ye.Content, { width: "2xl", "data-testid": "data-table-manager-drawer", children: [
+          /* @__PURE__ */ A(ye.Header, { children: [
+            /* @__PURE__ */ x(ye.Title, { children: n(R.settings) }),
+            /* @__PURE__ */ x(ye.CloseTrigger, {})
+          ] }),
+          /* @__PURE__ */ x(ye.Body, { children: /* @__PURE__ */ x(
+            Zn.Root,
+            {
+              tabs: [
+                {
+                  id: "visible-columns",
+                  tabLabel: /* @__PURE__ */ A(We, { children: [
+                    /* @__PURE__ */ x(Un, {}),
+                    n(R.visibleColumns)
+                  ] }),
+                  panelContent: /* @__PURE__ */ x(
+                    ii,
+                    {
+                      hiddenItems: m,
+                      visibleItems: h,
+                      handleVisibleColumnsUpdate: f,
+                      handleResetColumns: y
+                    }
+                  )
+                },
+                {
+                  id: "layout-settings",
+                  tabLabel: /* @__PURE__ */ A(We, { children: [
+                    /* @__PURE__ */ x(Gn, {}),
+                    n(R.layoutSettings)
+                  ] }),
+                  panelContent: /* @__PURE__ */ x(ri, { onSettingsChange: u })
+                }
+              ]
+            }
+          ) })
+        ] })
+      }
+    )
+  ] });
+};
+Ul.displayName = "DataTable.Manager";
+const ai = function({
+  ref: e,
+  footer: l,
+  ...n
+}) {
+  const o = he(), i = M(null), a = Q(Re(i, e));
+  return /* @__PURE__ */ A(pt, { ref: a, ...n, children: [
+    /* @__PURE__ */ A(mt, { "aria-label": o.formatMessage(R.dataTable), children: [
+      /* @__PURE__ */ x(
+        ft,
+        {
+          "aria-label": o.formatMessage(R.dataTableHeader)
+        }
+      ),
+      /* @__PURE__ */ x(
+        dt,
+        {
+          "aria-label": o.formatMessage(R.dataTableBody)
+        }
+      )
+    ] }),
+    l && /* @__PURE__ */ x(ct, { children: l })
+  ] });
+}, gr = /* @__PURE__ */ Object.assign(ai, {
+  Root: pt,
+  Table: mt,
+  Header: ft,
+  Column: ke,
+  Body: dt,
+  Row: st,
+  Cell: xe,
+  Footer: ct,
+  /**
+   * # 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: Ul,
+  ExpandButton: Hl,
+  NestedIcon: _o,
+  SelectionCell: Qo,
+  Context: Ye,
+  useDataTableContext: fe
+});
+export {
+  gr as D,
+  Mt as U,
+  pt as a,
+  mt as b,
+  ft as c,
+  ke as d,
+  dt as e,
+  st as f,
+  xe as g,
+  ct as h,
+  Ul as i,
+  Hl as j,
+  _o as k,
+  Qo as l
+};
+//# sourceMappingURL=data-table-C0o2YmP-.es.js.map