@commercetools/nimbus 2.9.0 → 2.10.0

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

@@ -0,0 +1,4626 @@
+import { jsx as x, jsxs as z, Fragment as Me } from "react/jsx-runtime";
+import D, { useRef as K, useCallback as M, useMemo as A, useState as Z, useEffect as he, useContext as E, forwardRef as J, createContext as ge } from "react";
+import { $ as ee } from "./useObjectRef-tuMEdnba.es.js";
+import { m as Le } from "./merge-refs-D-zSwpoh.es.js";
+import { n as Ie, u as ue } from "./normalize-messages-CeN1NEyM.es.js";
+import { ArrowDownward as bn, KeyboardArrowDown as yn, KeyboardArrowRight as xn, PushPin as $n, VisibilityOff as Cn, Visibility as vn, Refresh as wn, WrapText as Dn, ShortText as Sn, DensitySmall as kn, FormatAlignJustify as En, Settings as zn, ViewWeek as Pn, ViewDay as Kn } from "@commercetools/nimbus-icons";
+import { S as Ee } from "./simple-grid-DU5v66TG.es.js";
+import { B as se } from "./box-DuBoAZvq.es.js";
+import { S as An } from "./search-input-CE4Aadh5.es.js";
+import { $ as Rn, D as Ue } from "./draggable-list-bbz150ZU.es.js";
+import { S as Ye } from "./stack-CoNreM7B.es.js";
+import { T as Ve } from "./text-Ci0HmiFd.es.js";
+import { S as rl } from "./separator-Chb2smWb.es.js";
+import { B as Tn } from "./button-dtLOSwKi.es.js";
+import { I as Fe } from "./icon-toggle-button-Dg4SI2i3.es.js";
+import { T as Lt } from "./toolbar-DY_v_dEm.es.js";
+import { T as Ht } from "./toggle-button-group-70GS2Oxw.es.js";
+import { D as we } from "./drawer-ywS81xb5.es.js";
+import { T as Bn } from "./tabs-B35CbEex.es.js";
+import { T as qe } from "./tooltip-Bx5ngdcy.es.js";
+import { I as il } from "./icon-button-DwOSMjvL.es.js";
+import { createSlotRecipeContext as In } from "@chakra-ui/react/styled-system";
+import { $ as ol } from "./Button-i3wfJjZy.es.js";
+import { $ as al, C as sl } from "./checkbox-CZDjV_4N.es.js";
+import { a as be, b as N, $ as ul, e as tt, g as Wt } from "./utils-BBrLCz2b.es.js";
+import { m as me, n as Pe, $ as dl, f as O, b as Mn, a as Fn, o as Xe, e as Nn, g as cl, h as V, j as fl } from "./useCollection-BHV9RL7c.es.js";
+import { e as Ae, g as Vn, f as Ln, h as Hn, i as go } from "./ListBox-BQGvhjf1.es.js";
+import { $ as Ot, a as Wn } from "./Autocomplete-B1xvEyxv.es.js";
+import { $ as On } from "./intlStrings-DhlQ0Eoy.es.js";
+import { a as jn, $ as _n } from "./SelectionIndicator-BX52LU2T.es.js";
+import { c as gt, i as Un, g as He, f as Yn, j as Xn, a as lt, $ as pl, k as Gn, h as Co } from "./CollectionBuilder-CbqLnlVI.es.js";
+import { $ as ne } from "./filterDOMProps-BBiQzGq3.es.js";
+import { a as jt, b as qn } from "./FocusScope-D0jw9l8a.es.js";
+import { b as So } from "./useListState-CCuYEVMA.es.js";
+import { a as bt, c as De, $ as Zn } from "./useDescription-Cs3XF2eh.es.js";
+import { e as Jn, c as Qn } from "./getItemCount-BEy-gD1d.es.js";
+import { $ as yt, a as _, e as er, c as _t, b as tr } from "./mergeProps-Bcbq3GVJ.es.js";
+import lr from "react-dom";
+import { $ as ml } from "./useControlledState-BO6rCKQt.es.js";
+import { $ as Ke } from "./useFocusRing-2PACod61.es.js";
+import { $ as We } from "./useHover-BdXEf8Xj.es.js";
+import { $ as $e } from "./I18nProvider-BuwVdK1A.es.js";
+import { $ as Re } from "./useLocalizedStringFormatter-pZiuCYXV.es.js";
+import { a as nr } from "./useOverlayTriggerState-BIEvXItV.es.js";
+import { $ as rr } from "./LiveAnnouncer-BqzMb1lo.es.js";
+import { k as Se, a as Q, $ as Ze, n as Ut, d as Ge } from "./utils-QxBoGDA9.es.js";
+import { $ as hl } from "./useCollator-BHtcueqX.es.js";
+import { d as ir, e as or } from "./useGridListItem-DK2Qg6fD.es.js";
+import { $ as ar } from "./useHasTabbableChild-CwNEZI_G.es.js";
+import { $ as sr } from "./useUpdateEffect-CABB2-GV.es.js";
+import { $ as ur, g as Yt, r as dr, q as cr } from "./useFocusVisible-DZMx0daa.es.js";
+import { $ as fr, a as pr } from "./useFocusable-Cd_G32KV.es.js";
+import { $ as le } from "./focusSafely-DqnNk8Cr.es.js";
+import { $ as ke } from "./getScrollParent-DpFDagTz.es.js";
+import { a as mr, b as hr, $ as gl } from "./usePress-j9tEDUF8.es.js";
+import { $ as gr } from "./useLabels-HhoRmCva.es.js";
+import { $ as st } from "./useEffectEvent-CaJWcluo.es.js";
+import { $ as br } from "./useGlobalListeners-DCPJed-d.es.js";
+import { a as nt, $ as Xt } from "./VisuallyHidden-CQtTsK1P.es.js";
+import { e as Te } from "./extract-style-props-D_NsrT_t.es.js";
+import { Highlight as yr } from "@chakra-ui/react/highlight";
+import { F as xr } from "./flex-BqxAMF-7.es.js";
+function $r(t) {
+  let { onMoveStart: e, onMove: l, onMoveEnd: n } = t, r = K({
+    didMove: !1,
+    lastPosition: null,
+    id: null
+  }), { addGlobalListener: i, removeGlobalListener: o } = br(), u = M((f, p, h, b) => {
+    h === 0 && b === 0 || (r.current.didMove || (r.current.didMove = !0, e?.({
+      type: "movestart",
+      pointerType: p,
+      shiftKey: f.shiftKey,
+      metaKey: f.metaKey,
+      ctrlKey: f.ctrlKey,
+      altKey: f.altKey
+    })), l?.({
+      type: "move",
+      pointerType: p,
+      deltaX: h,
+      deltaY: b,
+      shiftKey: f.shiftKey,
+      metaKey: f.metaKey,
+      ctrlKey: f.ctrlKey,
+      altKey: f.altKey
+    }));
+  }, [
+    e,
+    l,
+    r
+  ]), s = st(u), c = M((f, p) => {
+    mr(), r.current.didMove && n?.({
+      type: "moveend",
+      pointerType: p,
+      shiftKey: f.shiftKey,
+      metaKey: f.metaKey,
+      ctrlKey: f.ctrlKey,
+      altKey: f.altKey
+    });
+  }, [
+    n,
+    r
+  ]), d = st(c);
+  return {
+    moveProps: A(() => {
+      let f = {}, p = () => {
+        hr(), r.current.didMove = !1;
+      };
+      if (typeof PointerEvent > "u" && process.env.NODE_ENV === "test") {
+        let b = (m) => {
+          m.button === 0 && (s(m, "mouse", m.pageX - (r.current.lastPosition?.pageX ?? 0), m.pageY - (r.current.lastPosition?.pageY ?? 0)), r.current.lastPosition = {
+            pageX: m.pageX,
+            pageY: m.pageY
+          });
+        }, C = (m) => {
+          if (m.button === 0) {
+            d(m, "mouse");
+            let w = Se(Q(m));
+            o(w, "mousemove", b, !1), o(w, "mouseup", C, !1);
+          }
+        };
+        f.onMouseDown = (m) => {
+          if (m.button === 0) {
+            p(), m.stopPropagation(), m.preventDefault(), r.current.lastPosition = {
+              pageX: m.pageX,
+              pageY: m.pageY
+            };
+            let w = Se(Q(m));
+            i(w, "mousemove", b, !1), i(w, "mouseup", C, !1);
+          }
+        };
+        let y = (m) => {
+          let w = [
+            ...m.changedTouches
+          ].findIndex(({ identifier: $ }) => $ === r.current.id);
+          if (w >= 0) {
+            let { pageX: $, pageY: S } = m.changedTouches[w];
+            s(m, "touch", $ - (r.current.lastPosition?.pageX ?? 0), S - (r.current.lastPosition?.pageY ?? 0)), r.current.lastPosition = {
+              pageX: $,
+              pageY: S
+            };
+          }
+        }, g = (m) => {
+          if ([
+            ...m.changedTouches
+          ].findIndex(({ identifier: $ }) => $ === r.current.id) >= 0) {
+            d(m, "touch"), r.current.id = null;
+            let $ = Se(Q(m));
+            o($, "touchmove", y), o($, "touchend", g), o($, "touchcancel", g);
+          }
+        };
+        f.onTouchStart = (m) => {
+          if (m.changedTouches.length === 0 || r.current.id != null) return;
+          let { pageX: w, pageY: $, identifier: S } = m.changedTouches[0];
+          p(), m.stopPropagation(), m.preventDefault(), r.current.lastPosition = {
+            pageX: w,
+            pageY: $
+          }, r.current.id = S;
+          let k = Se(Q(m));
+          i(k, "touchmove", y, !1), i(k, "touchend", g, !1), i(k, "touchcancel", g, !1);
+        };
+      } else {
+        let b = (y) => {
+          if (y.pointerId === r.current.id) {
+            let g = y.pointerType || "mouse";
+            s(y, g, y.pageX - (r.current.lastPosition?.pageX ?? 0), y.pageY - (r.current.lastPosition?.pageY ?? 0)), r.current.lastPosition = {
+              pageX: y.pageX,
+              pageY: y.pageY
+            };
+          }
+        }, C = (y) => {
+          if (y.pointerId === r.current.id) {
+            let g = y.pointerType || "mouse";
+            d(y, g), r.current.id = null;
+            let m = Se(Q(y));
+            o(m, "pointermove", b, !1), o(m, "pointerup", C, !1), o(m, "pointercancel", C, !1);
+          }
+        };
+        f.onPointerDown = (y) => {
+          if (y.button === 0 && r.current.id == null) {
+            p(), y.stopPropagation(), y.preventDefault(), r.current.lastPosition = {
+              pageX: y.pageX,
+              pageY: y.pageY
+            }, r.current.id = y.pointerId;
+            let g = Se(Q(y));
+            i(g, "pointermove", b, !1), i(g, "pointerup", C, !1), i(g, "pointercancel", C, !1);
+          }
+        };
+      }
+      let h = (b, C, y) => {
+        p(), s(b, "keyboard", C, y), d(b, "keyboard");
+      };
+      return f.onKeyDown = (b) => {
+        switch (b.key) {
+          case "Left":
+          case "ArrowLeft":
+            b.preventDefault(), b.stopPropagation(), h(b, -1, 0);
+            break;
+          case "Right":
+          case "ArrowRight":
+            b.preventDefault(), b.stopPropagation(), h(b, 1, 0);
+            break;
+          case "Up":
+          case "ArrowUp":
+            b.preventDefault(), b.stopPropagation(), h(b, 0, -1);
+            break;
+          case "Down":
+          case "ArrowDown":
+            b.preventDefault(), b.stopPropagation(), h(b, 0, 1);
+            break;
+        }
+      }, f;
+    }, [
+      i,
+      o,
+      r
+    ])
+  };
+}
+const Gt = 10, qt = 5;
+class Cr {
+  setup(e, l, n) {
+    this.delegate = e, this.state = l, this.direction = n;
+  }
+  getDropTargetFromPoint(e, l, n) {
+    let r = this.delegate.getDropTargetFromPoint(e, l, n);
+    return !r || r.type === "root" ? r : this.resolveDropTarget(r, e, l, n);
+  }
+  resolveDropTarget(e, l, n, r) {
+    let i = this.pointerTracking, o = n - i.lastY, u = l - i.lastX, s = i.yDirection, c = i.xDirection;
+    if (Math.abs(o) > qt && (s = o > 0 ? "down" : "up", i.yDirection = s, i.lastY = n), Math.abs(u) > Gt && (c = u > 0 ? "right" : "left", i.xDirection = c, i.lastX = l), e.dropPosition === "before") {
+      let f = this.state.collection.getKeyBefore(e.key);
+      if (f != null) {
+        let p = {
+          type: "item",
+          key: f,
+          dropPosition: "after"
+        };
+        r(p) && (e = p);
+      }
+    }
+    let d = this.getPotentialTargets(e, r);
+    if (d.length === 0) return {
+      type: "root"
+    };
+    let a;
+    return d.length > 1 ? a = this.selectTarget(d, e, l, n, s, c) : (a = d[0], i.boundaryContext = null), a;
+  }
+  // Returns potential targets for an ambiguous drop position (e.g. after the last child of a parent, or after the parent itself)
+  // Ordered by level, from innermost to outermost.
+  getPotentialTargets(e, l) {
+    if (e.dropPosition === "on") return [
+      e
+    ];
+    let n = e, r = this.state.collection, i = r.getItem(n.key);
+    for (; i && i?.type !== "item" && i.nextKey != null; )
+      n.key = i.nextKey, i = r.getItem(i.nextKey);
+    let o = [
+      n
+    ];
+    if (i && i.hasChildNodes && this.state.expandedKeys.has(i.key) && r.getChildren && n.dropPosition === "after") {
+      let c = i.firstChildKey != null ? r.getItem(i.firstChildKey) : null;
+      for (; c && c.type !== "item"; ) c = c.nextKey != null ? r.getItem(c.nextKey) : null;
+      if (c?.type === "item") {
+        const d = {
+          type: "item",
+          key: c.key,
+          dropPosition: "before"
+        };
+        return l(d) ? [
+          d
+        ] : [];
+      }
+    }
+    if (i?.nextKey != null) return [
+      e
+    ];
+    let u = i?.parentKey, s = [];
+    for (; u; ) {
+      let c = r.getItem(u), d = c?.nextKey ? r.getItem(c.nextKey) : null;
+      if (!d || d.parentKey !== u) {
+        let f = {
+          type: "item",
+          key: u,
+          dropPosition: "after"
+        };
+        if (l(f) && s.push(f), d) break;
+      }
+      u = c?.parentKey;
+    }
+    if (s.length > 0 && o.push(...s), o.length === 1) {
+      let c = r.getKeyAfter(n.key), d = c ? r.getItem(c) : null;
+      if (c != null && d && i && d.level != null && i.level != null && d.level > i.level) {
+        let a = {
+          type: "item",
+          key: c,
+          dropPosition: "before"
+        };
+        if (l(a)) return [
+          a
+        ];
+      }
+    }
+    return o.filter(l);
+  }
+  selectTarget(e, l, n, r, i, o) {
+    if (e.length < 2) return e[0];
+    let u = this.pointerTracking, c = this.state.collection.getItem(l.key)?.parentKey;
+    if (!c) return e[0];
+    if (!u.boundaryContext || u.boundaryContext.parentKey !== c) {
+      let h = u.yDirection === "up" ? e.length - 1 : 0;
+      u.boundaryContext = {
+        parentKey: c,
+        preferredTargetIndex: h,
+        lastSwitchY: r,
+        lastSwitchX: n
+      };
+    }
+    let d = u.boundaryContext, a = Math.abs(n - d.lastSwitchX);
+    if (Math.abs(r - d.lastSwitchY) > qt && i) {
+      let h = d.preferredTargetIndex || 0;
+      i === "down" && h === 0 ? d.preferredTargetIndex = e.length - 1 : i === "up" && h === e.length - 1 && (d.preferredTargetIndex = 0), u.xDirection = null;
+    }
+    if (a > Gt && o) {
+      let h = d.preferredTargetIndex || 0;
+      o === "left" ? this.direction === "ltr" ? h < e.length - 1 && (d.preferredTargetIndex = h + 1, d.lastSwitchX = n) : h > 0 && (d.preferredTargetIndex = h - 1, d.lastSwitchX = n) : o === "right" && (this.direction === "ltr" ? h > 0 && (d.preferredTargetIndex = h - 1, d.lastSwitchX = n) : h < e.length - 1 && (d.preferredTargetIndex = h + 1, d.lastSwitchX = n)), u.yDirection = null;
+    }
+    let p = Math.max(0, Math.min(d.preferredTargetIndex || 0, e.length - 1));
+    return e[p];
+  }
+  constructor() {
+    this.delegate = null, this.state = null, this.direction = "ltr", this.pointerTracking = {
+      lastY: 0,
+      lastX: 0,
+      yDirection: null,
+      xDirection: null,
+      boundaryContext: null
+    };
+  }
+}
+function vr(t) {
+  return t != null && (!isNaN(t) || String(t).match(/^(\d+)(?=%$)/) !== null);
+}
+function wr(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 xt(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 bl(t, e) {
+  return t != null ? xt(t, e) : Number.MAX_SAFE_INTEGER;
+}
+function yl(t, e) {
+  return t != null ? xt(t, e) : 0;
+}
+function Dr(t, e, l, n, r) {
+  let i = !1, o = e.map((u, s) => {
+    let c = l.get(u.key) != null ? l.get(u.key) ?? "1fr" : u.width ?? u.defaultWidth ?? n?.(s) ?? "1fr", d = !1, a = 0, f = 0, p = 0;
+    vr(c) ? (a = xt(c, t), d = !0) : (f = wr(c), f <= 0 && (d = !0));
+    let h = yl(u.minWidth ?? r?.(s) ?? 0, t), b = bl(u.maxWidth, t), C = Math.max(h, Math.min(a, b));
+    return d ? p = C : a > C && (d = !0, p = C), d || (i = !0), {
+      frozen: d,
+      baseSize: a,
+      hypotheticalMainSize: C,
+      min: h,
+      max: b,
+      flex: f,
+      targetMainSize: p,
+      violation: 0
+    };
+  });
+  for (; i; ) {
+    let u = 0, s = 0;
+    o.forEach((a) => {
+      a.frozen ? u += a.targetMainSize : (u += a.baseSize, s += a.flex);
+    });
+    let c = t - u;
+    c > 0 && o.forEach((a) => {
+      if (!a.frozen) {
+        let f = a.flex / s;
+        a.targetMainSize = a.baseSize + f * c;
+      }
+    });
+    let d = 0;
+    o.forEach((a) => {
+      if (a.violation = 0, !a.frozen) {
+        let { min: f, max: p, targetMainSize: h } = a;
+        a.targetMainSize = Math.max(f, Math.min(h, p)), a.violation = a.targetMainSize - h, d += a.violation;
+      }
+    }), i = !1, o.forEach((a) => {
+      d === 0 || Math.sign(d) === Math.sign(a.violation) ? a.frozen = !0 : a.frozen || (i = !0);
+    });
+  }
+  return Sr(o);
+}
+function Sr(t) {
+  let e = 0, l = 0, n = [];
+  return t.forEach(function(r) {
+    let i = r.targetMainSize, o = Math.round(i + e) - l;
+    e += i, l += o, n.push(o);
+  }), n;
+}
+class kr {
+  constructor(e) {
+    this.columnWidths = /* @__PURE__ */ new Map(), this.columnMinWidths = /* @__PURE__ */ new Map(), this.columnMaxWidths = /* @__PURE__ */ new Map(), this.getDefaultWidth = e?.getDefaultWidth ?? (() => "1fr"), this.getDefaultMinWidth = e?.getDefaultMinWidth ?? (() => 75);
+  }
+  /** 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, r) {
+    return new Map(e.map((i) => n.has(i.key) ? [
+      i.key,
+      l.get(i.key)
+    ] : [
+      i.key,
+      r.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]) => [
+      l,
+      n.props.defaultWidth ?? this.getDefaultWidth?.(n) ?? "1fr"
+    ]));
+  }
+  getColumnWidth(e) {
+    return this.columnWidths.get(e) ?? 0;
+  }
+  getColumnMinWidth(e) {
+    return this.columnMinWidths.get(e) ?? 0;
+  }
+  getColumnMaxWidth(e) {
+    return this.columnMaxWidths.get(e) ?? 0;
+  }
+  resizeColumnWidth(e, l, n, r) {
+    let i = this.columnWidths, o = !0, u = /* @__PURE__ */ new Map();
+    return r = Math.max(this.getColumnMinWidth(n), Math.min(this.getColumnMaxWidth(n), Math.floor(r))), e.columns.forEach((s) => {
+      s.key === n ? (u.set(s.key, r), o = !1) : o ? u.set(s.key, i.get(s.key) ?? 0) : u.set(s.key, s.props.width ?? 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(), Dr(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, o) => {
+      let u = l.columns[o].key, s = l.columns[o];
+      this.columnWidths.set(u, i), this.columnMinWidths.set(u, yl(s.props.minWidth ?? this.getDefaultMinWidth(s), e)), this.columnMaxWidths.set(u, bl(s.props.maxWidth, e));
+    }), this.columnWidths;
+  }
+}
+class Er {
+  constructor(e) {
+    this.keyMap = /* @__PURE__ */ new Map(), this.keyMap = /* @__PURE__ */ new Map(), this.columnCount = e?.columnCount, this.rows = [];
+    let l = (i) => {
+      let o = this.keyMap.get(i.key);
+      e.visitNode && (i = e.visitNode(i)), this.keyMap.set(i.key, i);
+      let u = /* @__PURE__ */ new Set(), s = null, c = !1;
+      if (i.type === "item") {
+        for (let d of i.childNodes) if (d.props?.colSpan !== void 0) {
+          c = !0;
+          break;
+        }
+      }
+      for (let d of i.childNodes)
+        d.type === "cell" && c && (d.colspan = d.props?.colSpan, d.colSpan = d.props?.colSpan, d.colIndex = s ? (s.colIndex ?? s.index) + (s.colSpan ?? 1) : d.index), d.type === "cell" && d.parentKey == null && (d.parentKey = i.key), u.add(d.key), s ? (s.nextKey = d.key, d.prevKey = s.key) : d.prevKey = null, l(d), s = d;
+      if (s && (s.nextKey = null), o)
+        for (let d of o.childNodes) u.has(d.key) || n(d);
+    }, n = (i) => {
+      this.keyMap.delete(i.key);
+      for (let o of i.childNodes) this.keyMap.get(o.key) === o && n(o);
+    }, r = null;
+    for (let [i, o] of e.items.entries()) {
+      let u = {
+        ...o,
+        level: o.level ?? 0,
+        key: o.key ?? "row-" + i,
+        type: o.type ?? "row",
+        value: o.value ?? null,
+        hasChildNodes: !0,
+        childNodes: [
+          ...o.childNodes
+        ],
+        rendered: o.rendered,
+        textValue: o.textValue ?? "",
+        index: o.index ?? i
+      };
+      r ? (r.nextKey = u.key, u.prevKey = r.key) : u.prevKey = null, this.rows.push(u), l(u), r = u;
+    }
+    r && (r.nextKey = null);
+  }
+  *[Symbol.iterator]() {
+    yield* [
+      ...this.rows
+    ];
+  }
+  get size() {
+    return [
+      ...this.rows
+    ].length;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(e) {
+    let l = this.keyMap.get(e);
+    return l ? l.prevKey ?? null : null;
+  }
+  getKeyAfter(e) {
+    let l = this.keyMap.get(e);
+    return l ? l.nextKey ?? null : null;
+  }
+  getFirstKey() {
+    return [
+      ...this.rows
+    ][0]?.key;
+  }
+  getLastKey() {
+    let e = [
+      ...this.rows
+    ];
+    return e[e.length - 1]?.key;
+  }
+  getItem(e) {
+    return this.keyMap.get(e) ?? null;
+  }
+  at(e) {
+    const l = [
+      ...this.getKeys()
+    ];
+    return this.getItem(l[e]);
+  }
+  getChildren(e) {
+    return this.keyMap.get(e)?.childNodes || [];
+  }
+}
+const xl = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+let ut = "row-header-column-" + /* @__PURE__ */ Math.random().toString(36).slice(2);
+for (; xl === ut; ) ut = "row-header-column-" + Math.random().toString(36).slice(2);
+function $l(t, e) {
+  if (e.length === 0) return [];
+  let l = [], n = /* @__PURE__ */ new Map();
+  for (let s of e) {
+    let c = s.parentKey, d = [
+      s
+    ];
+    for (; c; ) {
+      let a = t.get(c);
+      if (!a) break;
+      if (n.has(a)) {
+        a.colSpan ??= 0, a.colSpan++, a.colspan = a.colSpan;
+        let { column: f, index: p } = n.get(a);
+        if (p > d.length) break;
+        for (let h = p; h < d.length; h++) f.splice(h, 0, null);
+        for (let h = d.length; h < f.length; h++)
+          f[h] && n.has(f[h]) && (n.get(f[h]).index = h);
+      } else
+        a.colSpan = 1, a.colspan = 1, d.push(a), n.set(a, {
+          column: d,
+          index: d.length - 1
+        });
+      c = a.parentKey;
+    }
+    l.push(d), s.index = l.length - 1;
+  }
+  let r = Math.max(...l.map((s) => s.length)), i = Array(r).fill(0).map(() => []), o = 0;
+  for (let s of l) {
+    let c = r - 1;
+    for (let d of s) {
+      if (d) {
+        let a = i[c], f = a.reduce((p, h) => p + (h.colSpan ?? 1), 0);
+        if (f < o) {
+          let p = {
+            type: "placeholder",
+            key: "placeholder-" + d.key,
+            colspan: o - f,
+            colSpan: o - f,
+            index: f,
+            value: null,
+            rendered: null,
+            level: c,
+            hasChildNodes: !1,
+            childNodes: [],
+            textValue: ""
+          };
+          a.length > 0 && (a[a.length - 1].nextKey = p.key, p.prevKey = a[a.length - 1].key), a.push(p);
+        }
+        a.length > 0 && (a[a.length - 1].nextKey = d.key, d.prevKey = a[a.length - 1].key), d.level = c, d.colIndex = o, a.push(d);
+      }
+      c--;
+    }
+    o++;
+  }
+  let u = 0;
+  for (let s of i) {
+    let c = s.reduce((d, a) => d + (a.colSpan ?? 1), 0);
+    if (c < e.length) {
+      let d = {
+        type: "placeholder",
+        key: "placeholder-" + s[s.length - 1].key,
+        colSpan: e.length - c,
+        colspan: e.length - c,
+        index: c,
+        value: null,
+        rendered: null,
+        level: u,
+        hasChildNodes: !1,
+        childNodes: [],
+        textValue: "",
+        prevKey: s[s.length - 1].key
+      };
+      s.push(d);
+    }
+    u++;
+  }
+  return i.map((s, c) => ({
+    type: "headerrow",
+    key: "headerrow-" + c,
+    index: c,
+    value: null,
+    rendered: null,
+    level: 0,
+    hasChildNodes: !0,
+    childNodes: s,
+    textValue: ""
+  }));
+}
+class zr extends Er {
+  constructor(e, l, n) {
+    let r = /* @__PURE__ */ new Set(), i = null, o = [];
+    if (n?.showSelectionCheckboxes) {
+      let a = {
+        type: "column",
+        key: xl,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: n?.showDragButtons ? 1 : 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isSelectionCell: !0
+        }
+      };
+      o.unshift(a);
+    }
+    if (n?.showDragButtons) {
+      let a = {
+        type: "column",
+        key: ut,
+        value: null,
+        textValue: "",
+        level: 0,
+        index: 0,
+        hasChildNodes: !1,
+        rendered: null,
+        childNodes: [],
+        props: {
+          isDragButtonCell: !0
+        }
+      };
+      o.unshift(a);
+    }
+    let u = [], s = /* @__PURE__ */ new Map(), c = (a) => {
+      switch (a.type) {
+        case "body":
+          i = a;
+          break;
+        case "column":
+          s.set(a.key, a), a.hasChildNodes || (o.push(a), a.props.isRowHeader && r.add(a.key));
+          break;
+        case "item":
+          u.push(a);
+          return;
+      }
+      for (let f of a.childNodes) c(f);
+    };
+    for (let a of e) c(a);
+    let d = $l(s, o);
+    if (d.forEach((a, f) => u.splice(f, 0, a)), super({
+      columnCount: o.length,
+      items: u,
+      visitNode: (a) => (a.column = o[a.index], a)
+    }), this._size = 0, this.columns = o, this.rowHeaderColumnKeys = r, this.body = i, this.headerRows = d, this._size = [
+      ...i.childNodes
+    ].length, this.rowHeaderColumnKeys.size === 0) {
+      let a = this.columns.find((f) => !f.props?.isDragButtonCell && !f.props?.isSelectionCell);
+      a && this.rowHeaderColumnKeys.add(a.key);
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.body.childNodes;
+  }
+  get size() {
+    return this._size;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(e) {
+    return this.keyMap.get(e)?.prevKey ?? null;
+  }
+  getKeyAfter(e) {
+    return this.keyMap.get(e)?.nextKey ?? null;
+  }
+  getFirstKey() {
+    return me(this.body.childNodes)?.key ?? null;
+  }
+  getLastKey() {
+    return Pe(this.body.childNodes)?.key ?? null;
+  }
+  getItem(e) {
+    return e === this.body.key ? this.body : this.keyMap.get(e) ?? null;
+  }
+  at(e) {
+    const l = [
+      ...this.getKeys()
+    ];
+    return this.getItem(l[e]);
+  }
+  getChildren(e) {
+    if (e === this.body.key) return this.body.childNodes;
+    let l = this.getItem(e);
+    return l?.type === "item" ? [
+      ...l.childNodes
+    ].filter((n) => n.type === "cell") : 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 r = [];
+      for (let i of l.childNodes) {
+        let o = this.columns[i.index];
+        if (n.has(o.key) && i.textValue && r.push(i.textValue), r.length === n.size) break;
+      }
+      return r.join(" ");
+    }
+    return "";
+  }
+}
+function Pr(t, e) {
+  let { getDefaultWidth: l, getDefaultMinWidth: n, tableWidth: r = 0 } = t, [i, o] = Z(null), u = A(() => new kr({
+    getDefaultWidth: l,
+    getDefaultMinWidth: n
+  }), [
+    l,
+    n
+  ]), [s, c] = A(() => u.splitColumnsIntoControlledAndUncontrolled(e.collection.columns), [
+    e.collection.columns,
+    u
+  ]), [d, a] = Z(() => u.getInitialUncontrolledWidths(c)), [f, p] = Z(e.collection.columns);
+  if (e.collection.columns !== f) {
+    if (e.collection.columns.length !== f.length || e.collection.columns.some((m, w) => m.key !== f[w].key)) {
+      let m = u.getInitialUncontrolledWidths(c);
+      a(m);
+    }
+    p(e.collection.columns);
+  }
+  let h = A(() => u.recombineColumns(e.collection.columns, d, c, s), [
+    e.collection.columns,
+    d,
+    c,
+    s,
+    u
+  ]), b = M((m) => {
+    o(m);
+  }, [
+    o
+  ]), C = M((m, w) => {
+    let $ = u.resizeColumnWidth(e.collection, d, m, w), S = new Map(Array.from(c).map(([k]) => [
+      k,
+      $.get(k)
+    ]));
+    return S.set(m, w), a(S), $;
+  }, [
+    c,
+    a,
+    u,
+    e.collection,
+    d
+  ]), y = M(() => {
+    o(null);
+  }, [
+    o
+  ]), g = A(() => u.buildColumnWidths(r, e.collection, h), [
+    r,
+    e.collection,
+    h,
+    u
+  ]);
+  return A(() => ({
+    resizingColumn: i,
+    updateResizedColumns: C,
+    startResize: b,
+    endResize: y,
+    getColumnWidth: (m) => u.getColumnWidth(m),
+    getColumnMinWidth: (m) => u.getColumnMinWidth(m),
+    getColumnMaxWidth: (m) => u.getColumnMaxWidth(m),
+    tableState: e,
+    columnWidths: g
+  }), [
+    u,
+    g,
+    i,
+    C,
+    b,
+    y,
+    e
+  ]);
+}
+function Kr(t) {
+  let { collection: e, focusMode: l } = t, n = t.UNSAFE_selectionState || dl(t), r = A(() => t.disabledKeys ? new Set(t.disabledKeys) : /* @__PURE__ */ new Set(), [
+    t.disabledKeys
+  ]), i = n.setFocusedKey;
+  n.setFocusedKey = (s, c) => {
+    if (l === "cell" && s != null) {
+      let d = e.getItem(s);
+      if (d?.type === "item") {
+        let a = O(d, e);
+        c === "last" ? s = Pe(a)?.key ?? null : s = me(a)?.key ?? null;
+      }
+    }
+    i(s, c);
+  };
+  let o = A(() => new Mn(e, n), [
+    e,
+    n
+  ]);
+  const u = K(null);
+  return he(() => {
+    if (n.focusedKey != null && u.current && !e.getItem(n.focusedKey)) {
+      const s = u.current.getItem(n.focusedKey), c = s?.parentKey != null && (s.type === "cell" || s.type === "rowheader" || s.type === "column") ? u.current.getItem(s.parentKey) : s;
+      if (!c) {
+        n.setFocusedKey(null);
+        return;
+      }
+      const d = u.current.rows, a = e.rows, f = d.length - a.length;
+      let p = Math.min(f > 1 ? Math.max(c.index - f + 1, 0) : c.index, a.length - 1), h = null;
+      for (; p >= 0; ) {
+        if (!o.isDisabled(a[p].key) && a[p].type !== "headerrow") {
+          h = a[p];
+          break;
+        }
+        p < a.length - 1 ? p++ : (p > c.index && (p = c.index), p--);
+      }
+      if (h) {
+        const b = h.hasChildNodes ? [
+          ...O(h, e)
+        ] : [], C = h.hasChildNodes && c !== s && s && s.index < b.length ? b[s.index].key : h.key;
+        n.setFocusedKey(C);
+      } else n.setFocusedKey(null);
+    }
+    u.current = e;
+  }, [
+    e,
+    o,
+    n,
+    n.focusedKey
+  ]), {
+    collection: e,
+    disabledKeys: r,
+    isKeyboardNavigationDisabled: !1,
+    selectionManager: o
+  };
+}
+const Ar = {
+  ascending: "descending",
+  descending: "ascending"
+};
+function Rr(t) {
+  let [e, l] = Z(!1), { selectionMode: n = "none", showSelectionCheckboxes: r, showDragButtons: i, treeColumn: o = null } = t, u = A(() => ({
+    showSelectionCheckboxes: r && n !== "none",
+    showDragButtons: i,
+    selectionMode: n,
+    columns: []
+  }), [
+    t.children,
+    r,
+    n,
+    i
+  ]), s = Fn(t, M((p) => new zr(p, null, u), [
+    u
+  ]), u), { disabledKeys: c, selectionManager: d } = Kr({
+    ...t,
+    collection: s,
+    disabledBehavior: t.disabledBehavior || "selection"
+  }), [a, f] = ml(t.expandedKeys ? new Set(t.expandedKeys) : void 0, t.defaultExpandedKeys ? new Set(t.defaultExpandedKeys) : /* @__PURE__ */ new Set(), t.onExpandedChange);
+  return {
+    collection: s,
+    disabledKeys: c,
+    selectionManager: d,
+    showSelectionCheckboxes: t.showSelectionCheckboxes || !1,
+    sortDescriptor: t.sortDescriptor ?? null,
+    isKeyboardNavigationDisabled: s.size === 0 || e,
+    setKeyboardNavigationDisabled: l,
+    sort(p, h) {
+      t.onSortChange?.({
+        column: p,
+        direction: h ?? (t.sortDescriptor?.column === p ? Ar[t.sortDescriptor.direction] : "ascending")
+      });
+    },
+    expandedKeys: a,
+    toggleKey(p) {
+      f((h) => {
+        let b = new Set(h);
+        return b.has(p) ? b.delete(p) : b.add(p), b;
+      });
+    },
+    treeColumn: o
+  };
+}
+function Tr(t, e) {
+  let l = A(() => e ? t.collection.filter(e) : t.collection, [
+    t.collection,
+    e
+  ]), n = t.selectionManager.withCollection(l);
+  return {
+    ...t,
+    collection: l,
+    selectionManager: n
+  };
+}
+class Cl {
+  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 Br(e.layout) : new Jn(e.ref)), this.focusMode = e.focusMode ?? "row";
+  }
+  isCell(e) {
+    return e.type === "cell";
+  }
+  isRow(e) {
+    return e.type === "row" || e.type === "item";
+  }
+  isDisabled(e) {
+    return this.disabledBehavior === "all" && (e.props?.isDisabled || this.disabledKeys.has(e.key));
+  }
+  findPreviousKey(e, l) {
+    let n = e != null ? this.collection.getKeyBefore(e) : this.collection.getLastKey();
+    for (; n != null; ) {
+      let r = this.collection.getItem(n);
+      if (!r) return null;
+      if (!this.isDisabled(r) && (!l || l(r))) 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 r = this.collection.getItem(n);
+      if (!r) return null;
+      if (!this.isDisabled(r) && (!l || l(r))) 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 r = 0;
+    for (let i of O(n, this.collection)) {
+      if (i.colSpan && i.colSpan + r > l || (i.colSpan && (r = r + i.colSpan - 1), r === l)) return i.key ?? null;
+      r++;
+    }
+    return null;
+  }
+  getKeyBelow(e) {
+    let l = e, n = this.collection.getItem(l);
+    if (!n || (this.isCell(n) && (l = n.parentKey ?? null), l == null)) return null;
+    if (l = this.findNextKey(l, (r) => r.type === "item"), l != null) {
+      if (this.isCell(n)) {
+        let r = n.colIndex ? n.colIndex : n.index;
+        return this.getKeyForItemInRowByIndex(l, r);
+      }
+      if (this.focusMode === "row") return l;
+    }
+    return null;
+  }
+  getKeyAbove(e) {
+    let l = e, n = this.collection.getItem(l);
+    if (!n || (this.isCell(n) && (l = n.parentKey ?? null), l == null)) return null;
+    if (l = this.findPreviousKey(l, (r) => r.type === "item"), l != null) {
+      if (this.isCell(n)) {
+        let r = n.colIndex ? n.colIndex : n.index;
+        return this.getKeyForItemInRowByIndex(l, r);
+      }
+      if (this.focusMode === "row") return l;
+    }
+    return null;
+  }
+  getKeyRightOf(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (this.isRow(l)) {
+      let n = O(l, this.collection);
+      return (this.direction === "rtl" ? Pe(n)?.key : me(n)?.key) ?? null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let n = this.collection.getItem(l.parentKey);
+      if (!n) return null;
+      let r = O(n, this.collection), i = (this.direction === "rtl" ? Xe(r, l.index - 1) : Xe(r, l.index + 1)) ?? null;
+      return i ? i.key ?? null : this.focusMode === "row" ? l.parentKey ?? null : (this.direction === "rtl" ? this.getFirstKey(e) : this.getLastKey(e)) ?? null;
+    }
+    return null;
+  }
+  getKeyLeftOf(e) {
+    let l = this.collection.getItem(e);
+    if (!l) return null;
+    if (this.isRow(l)) {
+      let n = O(l, this.collection);
+      return (this.direction === "rtl" ? me(n)?.key : Pe(n)?.key) ?? null;
+    }
+    if (this.isCell(l) && l.parentKey != null) {
+      let n = this.collection.getItem(l.parentKey);
+      if (!n) return null;
+      let r = O(n, this.collection), i = (this.direction === "rtl" ? Xe(r, l.index + 1) : Xe(r, l.index - 1)) ?? null;
+      return i ? i.key ?? null : this.focusMode === "row" ? l.parentKey ?? null : (this.direction === "rtl" ? this.getLastKey(e) : this.getFirstKey(e)) ?? null;
+    }
+    return null;
+  }
+  getFirstKey(e, l) {
+    let n = e ?? null, r;
+    if (n != null) {
+      if (r = this.collection.getItem(n), !r) return null;
+      if (this.isCell(r) && !l && r.parentKey != null) {
+        let i = this.collection.getItem(r.parentKey);
+        return i ? me(O(i, this.collection))?.key ?? null : null;
+      }
+    }
+    if (n = this.findNextKey(void 0, (i) => i.type === "item"), n != null && (r && this.isCell(r) && l || this.focusMode === "cell")) {
+      let i = this.collection.getItem(n);
+      if (!i) return null;
+      n = me(O(i, this.collection))?.key ?? null;
+    }
+    return n;
+  }
+  getLastKey(e, l) {
+    let n = e ?? null, r;
+    if (n != null) {
+      if (r = this.collection.getItem(n), !r) return null;
+      if (this.isCell(r) && !l && r.parentKey != null) {
+        let i = this.collection.getItem(r.parentKey);
+        if (!i) return null;
+        let o = O(i, this.collection);
+        return Pe(o)?.key ?? null;
+      }
+    }
+    if (n = this.findPreviousKey(void 0, (i) => i.type === "item"), n != null && (r && this.isCell(r) && l || this.focusMode === "cell")) {
+      let i = this.collection.getItem(n);
+      if (!i) return null;
+      let o = O(i, this.collection);
+      n = Pe(o)?.key ?? null;
+    }
+    return n;
+  }
+  getKeyPageAbove(e) {
+    let l = e, n = this.layoutDelegate.getItemRect(l);
+    if (!n) return null;
+    let r = Math.max(0, n.y + n.height - this.layoutDelegate.getVisibleRect().height);
+    for (; n && n.y > r && l != null && (l = this.getKeyAbove(l) ?? null, l != null); )
+      n = this.layoutDelegate.getItemRect(l);
+    return l;
+  }
+  getKeyPageBelow(e) {
+    let l = e, n = this.layoutDelegate.getItemRect(l);
+    if (!n) return null;
+    let r = this.layoutDelegate.getVisibleRect().height, i = Math.min(this.layoutDelegate.getContentSize().height, n.y + r);
+    for (; n && n.y + n.height < i; ) {
+      let o = this.getKeyBelow(l);
+      if (o == null) break;
+      n = this.layoutDelegate.getItemRect(o), l = o;
+    }
+    return l;
+  }
+  getKeyForSearch(e, l) {
+    let n = l ?? null;
+    if (!this.collator) return null;
+    let r = this.collection;
+    if (n = l ?? this.getFirstKey(), n == null) return null;
+    let i = r.getItem(n);
+    if (!i) return null;
+    i.type === "cell" && (n = i.parentKey ?? null);
+    let o = !1;
+    for (; n != null; ) {
+      let u = r.getItem(n);
+      if (!u) return null;
+      if (u.textValue) {
+        let s = u.textValue.slice(0, e.length);
+        if (this.collator.compare(s, e) === 0)
+          return this.isRow(u) && this.focusMode === "cell" ? me(O(u, this.collection))?.key ?? null : u.key;
+      }
+      n = this.findNextKey(n, (s) => s.type === "item"), n == null && !o && (n = this.getFirstKey(), o = !0);
+    }
+    return null;
+  }
+}
+class Br {
+  constructor(e) {
+    this.layout = e;
+  }
+  getContentSize() {
+    return this.layout.getContentSize();
+  }
+  getItemRect(e) {
+    return this.layout.getLayoutInfo(e)?.rect || null;
+  }
+  getVisibleRect() {
+    return this.layout.virtualizer.visibleRect;
+  }
+}
+const $t = /* @__PURE__ */ new WeakMap();
+function Ir(t, e, l) {
+  let { isVirtualized: n, disallowTypeAhead: r, keyboardDelegate: i, focusMode: o, scrollRef: u, getRowText: s, onRowAction: c, onCellAction: d, escapeKeyBehavior: a = "clearSelection", shouldSelectOnPressUp: f } = t, { selectionManager: p } = e;
+  !t["aria-label"] && !t["aria-labelledby"] && console.warn("An aria-label or aria-labelledby prop is required for accessibility.");
+  let h = hl({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: b } = $e(), C = e.selectionManager.disabledBehavior, y = A(() => i || new Cl({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: C,
+    ref: l,
+    direction: b,
+    collator: h,
+    focusMode: o
+  }), [
+    i,
+    e.collection,
+    e.disabledKeys,
+    C,
+    l,
+    b,
+    h,
+    o
+  ]), { collectionProps: g } = Nn({
+    ref: l,
+    selectionManager: p,
+    keyboardDelegate: y,
+    isVirtualized: n,
+    scrollRef: u,
+    disallowTypeAhead: r,
+    escapeKeyBehavior: a
+  }), m = yt(t.id);
+  $t.set(e, {
+    keyboardDelegate: y,
+    actions: {
+      onRowAction: c,
+      onCellAction: d
+    },
+    shouldSelectOnPressUp: f
+  });
+  let w = ir({
+    selectionManager: p,
+    hasItemActions: !!(c || d)
+  }), $ = ne(t, {
+    labelable: !0
+  }), S = M((F) => {
+    if (p.isFocused) {
+      Ze(F.currentTarget, Q(F)) || p.setFocused(!1);
+      return;
+    }
+    Ze(F.currentTarget, Q(F)) && p.setFocused(!0);
+  }, [
+    p
+  ]), k = A(() => ({
+    onBlur: g.onBlur,
+    onFocus: S
+  }), [
+    S,
+    g.onBlur
+  ]), B = ar(l, {
+    isDisabled: e.collection.size !== 0
+  }), R = _(
+    $,
+    {
+      role: "grid",
+      id: m,
+      "aria-multiselectable": p.selectionMode === "multiple" ? "true" : void 0
+    },
+    e.isKeyboardNavigationDisabled ? k : g,
+    // If collection is empty, make sure the grid is tabbable unless there is a child tabbable element.
+    e.collection.size === 0 && {
+      tabIndex: B ? -1 : 0
+    } || void 0,
+    w
+  );
+  return n && (R["aria-rowcount"] = e.collection.size, R["aria-colcount"] = e.collection.columnCount), or({
+    getRowText: s
+  }, e), {
+    gridProps: R
+  };
+}
+const Ct = /* @__PURE__ */ new WeakMap();
+function dt(t) {
+  return typeof t == "string" ? t.replace(/\s*/g, "") : "" + t;
+}
+function vl(t, e) {
+  let l = Ct.get(t);
+  if (!l) throw new Error("Unknown grid");
+  return `${l}-${dt(e)}`;
+}
+function wl(t, e, l) {
+  let n = Ct.get(t);
+  if (!n) throw new Error("Unknown grid");
+  return `${n}-${dt(e)}-${dt(l)}`;
+}
+function ct(t, e) {
+  return [
+    ...t.collection.rowHeaderColumnKeys
+  ].map((l) => wl(t, e, l)).join(" ");
+}
+var Dl = {};
+Dl = {
+  ascending: "تصاعدي",
+  ascendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تصاعدي`,
+  columnSize: (t) => `${t.value} بالبكسل`,
+  descending: "تنازلي",
+  descendingSort: (t) => `ترتيب حسب العمود ${t.columnName} بترتيب تنازلي`,
+  resizerDescription: "اضغط على مفتاح Enter لبدء تغيير الحجم",
+  select: "تحديد",
+  selectAll: "تحديد الكل",
+  sortable: "عمود قابل للترتيب",
+  collapse: "طي",
+  expand: "تمديد"
+};
+var Sl = {};
+Sl = {
+  ascending: "възходящ",
+  ascendingSort: (t) => `сортирано по колона ${t.columnName} във възходящ ред`,
+  columnSize: (t) => `${t.value} пиксела`,
+  descending: "низходящ",
+  descendingSort: (t) => `сортирано по колона ${t.columnName} в низходящ ред`,
+  resizerDescription: "Натиснете „Enter“, за да започнете да преоразмерявате",
+  select: "Изберете",
+  selectAll: "Изберете всичко",
+  sortable: "сортираща колона",
+  collapse: "Свиване",
+  expand: "Разширяване"
+};
+var kl = {};
+kl = {
+  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í",
+  collapse: "Sbalit",
+  expand: "Roztáhnout"
+};
+var El = {};
+El = {
+  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",
+  collapse: "Skjul",
+  expand: "Udvid"
+};
+var zl = {};
+zl = {
+  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",
+  collapse: "Reduzieren",
+  expand: "Erweitern"
+};
+var Pl = {};
+Pl = {
+  ascending: "αύξουσα",
+  ascendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε αύξουσα σειρά`,
+  columnSize: (t) => `${t.value} pixel`,
+  descending: "φθίνουσα",
+  descendingSort: (t) => `διαλογή ανά στήλη ${t.columnName} σε φθίνουσα σειρά`,
+  resizerDescription: "Πατήστε Enter για έναρξη της αλλαγής μεγέθους",
+  select: "Επιλογή",
+  selectAll: "Επιλογή όλων",
+  sortable: "Στήλη διαλογής",
+  collapse: "Σύμπτυξη",
+  expand: "Ανάπτυξη"
+};
+var Kl = {};
+Kl = {
+  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",
+  expand: "Expand",
+  collapse: "Collapse"
+};
+var Al = {};
+Al = {
+  ascending: "ascendente",
+  ascendingSort: (t) => `ordenado por columna ${t.columnName} en sentido ascendente`,
+  columnSize: (t) => `${t.value} píxeles`,
+  descending: "descendente",
+  descendingSort: (t) => `ordenado por columna ${t.columnName} en orden descendente`,
+  resizerDescription: "Pulse Intro para empezar a redimensionar",
+  select: "Seleccionar",
+  selectAll: "Seleccionar todos",
+  sortable: "columna ordenable",
+  collapse: "Contraer",
+  expand: "Ampliar"
+};
+var Rl = {};
+Rl = {
+  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",
+  collapse: "Ahenda",
+  expand: "Laienda"
+};
+var Tl = {};
+Tl = {
+  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",
+  collapse: "Pienennä",
+  expand: "Laajenna"
+};
+var Bl = {};
+Bl = {
+  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",
+  collapse: "Réduire",
+  expand: "Développer"
+};
+var Il = {};
+Il = {
+  ascending: "עולה",
+  ascendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר עולה`,
+  columnSize: (t) => `${t.value} פיקסלים`,
+  descending: "יורד",
+  descendingSort: (t) => `מוין לפי עמודה ${t.columnName} בסדר יורד`,
+  resizerDescription: "הקש Enter כדי לשנות את הגודל",
+  select: "בחר",
+  selectAll: "בחר הכול",
+  sortable: "עמודה שניתן למיין",
+  collapse: "כווץ",
+  expand: "הרחב"
+};
+var Ml = {};
+Ml = {
+  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",
+  collapse: "Sažmi",
+  expand: "Proširi"
+};
+var Fl = {};
+Fl = {
+  ascending: "növekvő",
+  ascendingSort: (t) => `rendezve a(z) ${t.columnName} oszlop szerint, növekvő sorrendben`,
+  columnSize: (t) => `${t.value} képpont`,
+  descending: "csökkenő",
+  descendingSort: (t) => `rendezve a(z) ${t.columnName} oszlop szerint, csökkenő sorrendben`,
+  resizerDescription: "Nyomja le az Enter billentyűt az átméretezés megkezdéséhez",
+  select: "Kijelölés",
+  selectAll: "Összes kijelölése",
+  sortable: "rendezendő oszlop",
+  collapse: "Összecsukás",
+  expand: "Kibontás"
+};
+var Nl = {};
+Nl = {
+  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",
+  collapse: "Comprimi",
+  expand: "Espandi"
+};
+var Vl = {};
+Vl = {
+  ascending: "昇順",
+  ascendingSort: (t) => `列 ${t.columnName} を昇順で並べ替え`,
+  columnSize: (t) => `${t.value} ピクセル`,
+  descending: "降順",
+  descendingSort: (t) => `列 ${t.columnName} を降順で並べ替え`,
+  resizerDescription: "Enter キーを押してサイズ変更を開始",
+  select: "選択",
+  selectAll: "すべて選択",
+  sortable: "並べ替え可能な列",
+  collapse: "折りたたむ",
+  expand: "展開"
+};
+var Ll = {};
+Ll = {
+  ascending: "오름차순",
+  ascendingSort: (t) => `${t.columnName} 열을 기준으로 오름차순으로 정렬됨`,
+  columnSize: (t) => `${t.value} 픽셀`,
+  descending: "내림차순",
+  descendingSort: (t) => `${t.columnName} 열을 기준으로 내림차순으로 정렬됨`,
+  resizerDescription: "크기 조정을 시작하려면 Enter를 누르세요.",
+  select: "선택",
+  selectAll: "모두 선택",
+  sortable: "정렬 가능한 열",
+  collapse: "접기",
+  expand: "펼치기"
+};
+var Hl = {};
+Hl = {
+  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",
+  collapse: "Sutraukti",
+  expand: "Išskleisti"
+};
+var Wl = {};
+Wl = {
+  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",
+  collapse: "Sakļaut",
+  expand: "Izvērst"
+};
+var Ol = {};
+Ol = {
+  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",
+  collapse: "Skjul",
+  expand: "Utvid"
+};
+var jl = {};
+jl = {
+  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",
+  collapse: "Samenvouwen",
+  expand: "Uitvouwen"
+};
+var _l = {};
+_l = {
+  ascending: "rosnąco",
+  ascendingSort: (t) => `posortowano według kolumny ${t.columnName} w porządku rosnącym`,
+  columnSize: (t) => `Liczba pikseli: ${t.value}`,
+  descending: "malejąco",
+  descendingSort: (t) => `posortowano według kolumny ${t.columnName} w porządku malejącym`,
+  resizerDescription: "Naciśnij Enter, aby rozpocząć zmienianie rozmiaru",
+  select: "Zaznacz",
+  selectAll: "Zaznacz wszystko",
+  sortable: "kolumna z możliwością sortowania",
+  collapse: "Zwiń",
+  expand: "Rozwiń"
+};
+var Ul = {};
+Ul = {
+  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",
+  collapse: "Recolher",
+  expand: "Expandir"
+};
+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",
+  collapse: "Colapsar",
+  expand: "Expandir"
+};
+var Xl = {};
+Xl = {
+  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ă",
+  collapse: "Restrângeți",
+  expand: "Extindeți"
+};
+var Gl = {};
+Gl = {
+  ascending: "возрастание",
+  ascendingSort: (t) => `сортировать столбец ${t.columnName} в порядке возрастания`,
+  columnSize: (t) => `${t.value} пикс.`,
+  descending: "убывание",
+  descendingSort: (t) => `сортировать столбец ${t.columnName} в порядке убывания`,
+  resizerDescription: "Нажмите клавишу Enter для начала изменения размеров",
+  select: "Выбрать",
+  selectAll: "Выбрать все",
+  sortable: "сортируемый столбец",
+  collapse: "Свернуть",
+  expand: "Развернуть"
+};
+var ql = {};
+ql = {
+  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",
+  collapse: "Zbaliť",
+  expand: "Rozbaliť"
+};
+var Zl = {};
+Zl = {
+  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",
+  collapse: "Strni",
+  expand: "Razširi"
+};
+var Jl = {};
+Jl = {
+  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",
+  collapse: " Skupi",
+  expand: "Proširi"
+};
+var Ql = {};
+Ql = {
+  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",
+  collapse: "Dölj",
+  expand: "Expandera"
+};
+var en = {};
+en = {
+  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",
+  collapse: "Daralt",
+  expand: "Genişlet"
+};
+var tn = {};
+tn = {
+  ascending: "висхідний",
+  ascendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у висхідному порядку`,
+  columnSize: (t) => `${t.value} пікс.`,
+  descending: "низхідний",
+  descendingSort: (t) => `відсортовано за стовпцем ${t.columnName} у низхідному порядку`,
+  resizerDescription: "Натисніть Enter, щоб почати зміну розміру",
+  select: "Вибрати",
+  selectAll: "Вибрати все",
+  sortable: "сортувальний стовпець",
+  collapse: "Згорнути",
+  expand: "Розгорнути"
+};
+var ln = {};
+ln = {
+  ascending: "升序",
+  ascendingSort: (t) => `按列 ${t.columnName} 升序排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "降序",
+  descendingSort: (t) => `按列 ${t.columnName} 降序排序`,
+  resizerDescription: "按“输入”键开始调整大小。",
+  select: "选择",
+  selectAll: "全选",
+  sortable: "可排序的列",
+  collapse: "折叠",
+  expand: "扩展"
+};
+var nn = {};
+nn = {
+  ascending: "遞增",
+  ascendingSort: (t) => `已依據「${t.columnName}」欄遞增排序`,
+  columnSize: (t) => `${t.value} 像素`,
+  descending: "遞減",
+  descendingSort: (t) => `已依據「${t.columnName}」欄遞減排序`,
+  resizerDescription: "按 Enter 鍵以開始調整大小",
+  select: "選取",
+  selectAll: "全選",
+  sortable: "可排序的欄",
+  collapse: "收合",
+  expand: "展開"
+};
+var Be = {};
+Be = {
+  "ar-AE": Dl,
+  "bg-BG": Sl,
+  "cs-CZ": kl,
+  "da-DK": El,
+  "de-DE": zl,
+  "el-GR": Pl,
+  "en-US": Kl,
+  "es-ES": Al,
+  "et-EE": Rl,
+  "fi-FI": Tl,
+  "fr-FR": Bl,
+  "he-IL": Il,
+  "hr-HR": Ml,
+  "hu-HU": Fl,
+  "it-IT": Nl,
+  "ja-JP": Vl,
+  "ko-KR": Ll,
+  "lt-LT": Hl,
+  "lv-LV": Wl,
+  "nb-NO": Ol,
+  "nl-NL": jl,
+  "pl-PL": _l,
+  "pt-BR": Ul,
+  "pt-PT": Yl,
+  "ro-RO": Xl,
+  "ru-RU": Gl,
+  "sk-SK": ql,
+  "sl-SI": Zl,
+  "sr-SP": Jl,
+  "sv-SE": Ql,
+  "tr-TR": en,
+  "uk-UA": tn,
+  "zh-CN": ln,
+  "zh-TW": nn
+};
+class Mr extends Cl {
+  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 = me(O(l, this.collection));
+      if (n) return n.key;
+      let r = this.getFirstKey();
+      return r == null || !this.collection.getItem(r) ? null : super.getKeyForItemInRowByIndex(r, 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), r = n != null ? this.collection.getItem(n) : null;
+    return r && r.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, (r) => r.type === "column");
+    if (l != null) return l;
+    let n = this.collection.headerRows[e.level];
+    for (let r of O(n, this.collection))
+      if (r.type === "column") return r.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], r = [
+      ...O(n, this.collection)
+    ];
+    for (let i = r.length - 1; i >= 0; i--) {
+      let o = r[i];
+      if (o.type === "column") return o.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, r = l ?? this.getFirstKey();
+    if (r == null) return null;
+    let i = n.getItem(r);
+    i?.type === "cell" && (r = i.parentKey ?? null);
+    let o = !1;
+    for (; r != null; ) {
+      let u = n.getItem(r);
+      if (!u) return null;
+      if (u.textValue) {
+        let s = u.textValue.slice(0, e.length);
+        if (this.collator.compare(s, e) === 0) return u.key;
+      }
+      for (let s of O(u, this.collection)) {
+        let c = n.columns[s.index];
+        if (n.rowHeaderColumnKeys.has(c.key) && s.textValue) {
+          let d = s.textValue.slice(0, e.length);
+          if (this.collator.compare(d, e) === 0)
+            return (l != null ? n.getItem(l) : i)?.type === "cell" ? s.key : u.key;
+        }
+      }
+      r = this.getKeyBelow(r), r == null && !o && (r = this.getFirstKey(), o = !0);
+    }
+    return null;
+  }
+}
+function Fr(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function Nr(t, e, l) {
+  let { keyboardDelegate: n, isVirtualized: r, layoutDelegate: i, layout: o } = t, u = hl({
+    usage: "search",
+    sensitivity: "base"
+  }), { direction: s } = $e(), c = e.selectionManager.disabledBehavior, d = A(() => n || new Mr({
+    collection: e.collection,
+    disabledKeys: e.disabledKeys,
+    disabledBehavior: c,
+    ref: l,
+    direction: s,
+    collator: u,
+    layoutDelegate: i,
+    layout: o
+  }), [
+    n,
+    e.collection,
+    e.disabledKeys,
+    c,
+    l,
+    s,
+    u,
+    i,
+    o
+  ]), a = yt(t.id);
+  Ct.set(e, a);
+  let { gridProps: f } = Ir({
+    ...t,
+    id: a,
+    keyboardDelegate: d
+  }, e, l);
+  r && (f["aria-rowcount"] = e.collection.size + e.collection.headerRows.length), e.treeColumn != null && (f.role = "treegrid");
+  let { column: p, direction: h } = e.sortDescriptor || {}, b = Re(Fr(Be), "@react-aria/table"), C = A(() => {
+    let g = e.collection.columns.find((m) => m.key === p)?.textValue ?? "";
+    return h && p ? b.format(`${h}Sort`, {
+      columnName: g
+    }) : void 0;
+  }, [
+    h,
+    p,
+    e.collection.columns
+  ]), y = bt(C);
+  return sr(() => {
+    C && rr(C, "assertive", 500);
+  }, [
+    C
+  ]), {
+    gridProps: _(f, y, {
+      // merge sort description with long press information
+      "aria-describedby": [
+        y["aria-describedby"],
+        f["aria-describedby"]
+      ].filter(Boolean).join(" ")
+    })
+  };
+}
+function rn(t, e, l) {
+  let { node: n, isVirtualized: r, focusMode: i = "child", shouldSelectOnPressUp: o, onAction: u } = t, { direction: s } = $e(), { keyboardDelegate: c, actions: { onCellAction: d } } = $t.get(e), a = K(null), f = () => {
+    if (l.current) {
+      let g = jt(l.current);
+      if (i === "child") {
+        if (Ut(l.current) && l.current !== Ge()) return;
+        let m = e.selectionManager.childFocusStrategy === "last" ? at(g) : g.firstChild();
+        if (m) {
+          le(m);
+          return;
+        }
+      }
+      (a.current != null && n.key !== a.current || !Ut(l.current)) && le(l.current);
+    }
+  }, { itemProps: p, isPressed: h } = cl({
+    selectionManager: e.selectionManager,
+    key: n.key,
+    ref: l,
+    isVirtualized: r,
+    focus: f,
+    shouldSelectOnPressUp: o,
+    onAction: d ? () => d(n.key) : u,
+    isDisabled: e.collection.size === 0
+  }), b = (g) => {
+    let m = Ge();
+    if (!Ze(g.currentTarget, Q(g)) || e.isKeyboardNavigationDisabled || !l.current || !m) return;
+    let w = jt(l.current);
+    switch (w.currentNode = m, g.key) {
+      case "ArrowLeft": {
+        let $ = s === "rtl" ? w.nextNode() : w.previousNode();
+        if (i === "child" && $ === l.current && ($ = null), g.preventDefault(), g.stopPropagation(), $)
+          le($), De($, {
+            containingElement: ke(l.current)
+          });
+        else {
+          if (c.getKeyLeftOf?.(n.key) !== n.key) {
+            l.current.parentElement?.dispatchEvent(new KeyboardEvent(g.nativeEvent.type, g.nativeEvent));
+            break;
+          }
+          i === "cell" && s === "rtl" ? (le(l.current), De(l.current, {
+            containingElement: ke(l.current)
+          })) : (w.currentNode = l.current, $ = s === "rtl" ? w.firstChild() : at(w), $ && (le($), De($, {
+            containingElement: ke(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowRight": {
+        let $ = s === "rtl" ? w.previousNode() : w.nextNode();
+        if (i === "child" && $ === l.current && ($ = null), g.preventDefault(), g.stopPropagation(), $)
+          le($), De($, {
+            containingElement: ke(l.current)
+          });
+        else {
+          if (c.getKeyRightOf?.(n.key) !== n.key) {
+            l.current.parentElement?.dispatchEvent(new KeyboardEvent(g.nativeEvent.type, g.nativeEvent));
+            break;
+          }
+          i === "cell" && s === "ltr" ? (le(l.current), De(l.current, {
+            containingElement: ke(l.current)
+          })) : (w.currentNode = l.current, $ = s === "rtl" ? at(w) : w.firstChild(), $ && (le($), De($, {
+            containingElement: ke(l.current)
+          })));
+        }
+        break;
+      }
+      case "ArrowUp":
+      case "ArrowDown":
+        !g.altKey && Ze(l.current, Q(g)) && (g.stopPropagation(), g.preventDefault(), l.current.parentElement?.dispatchEvent(new KeyboardEvent(g.nativeEvent.type, g.nativeEvent)));
+        break;
+    }
+  }, C = (g) => {
+    if (a.current = n.key, Q(g) !== l.current) {
+      ur() || e.selectionManager.setFocusedKey(n.key);
+      return;
+    }
+    requestAnimationFrame(() => {
+      i === "child" && Ge() === l.current && f();
+    });
+  }, y = _(p, {
+    role: "gridcell",
+    onKeyDownCapture: b,
+    "aria-colspan": n.colSpan,
+    "aria-colindex": n.colIndex != null ? n.colIndex + 1 : void 0,
+    colSpan: r ? void 0 : n.colSpan,
+    onFocus: C
+  });
+  return r && (y["aria-colindex"] = (n.colIndex ?? n.index) + 1), o && y.tabIndex != null && y.onPointerDown == null && (y.onPointerDown = (g) => {
+    let m = g.currentTarget, w = m.getAttribute("tabindex");
+    m.removeAttribute("tabindex"), requestAnimationFrame(() => {
+      w != null && m.setAttribute("tabindex", w);
+    });
+  }), {
+    gridCellProps: y,
+    isPressed: h
+  };
+}
+function at(t) {
+  let e = null, l = null;
+  do
+    l = t.lastChild(), l && (e = l);
+  while (l);
+  return e;
+}
+function Vr(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function Lr(t, e, l) {
+  let { node: n } = t, r = n.props.allowsSorting, { gridCellProps: i } = rn({
+    ...t,
+    focusMode: "child"
+  }, e, l), o = n.props.isSelectionCell && e.selectionManager.selectionMode === "single", { pressProps: u, isPressed: s } = gl({
+    isDisabled: !r || o,
+    onPress() {
+      e.sort(n.key);
+    },
+    ref: l
+  }), { focusableProps: c } = fr({}, l), d, a = e.sortDescriptor?.column === n.key, f = e.sortDescriptor?.direction;
+  n.props.allowsSorting && !Yt() && (d = a ? f : "none");
+  let p = Re(Vr(Be), "@react-aria/table"), h;
+  r && (h = `${p.format("sortable")}`, a && f && Yt() && (h = `${h}, ${p.format(f)}`));
+  let b = bt(h), C = e.collection.size === 0;
+  return he(() => {
+    C && e.selectionManager.focusedKey === n.key && e.selectionManager.setFocusedKey(null);
+  }, [
+    C,
+    e.selectionManager,
+    n.key
+  ]), {
+    columnHeaderProps: {
+      ..._(
+        c,
+        i,
+        u,
+        b,
+        // If the table is empty, make all column headers untabbable
+        C ? {
+          tabIndex: -1
+        } : null
+      ),
+      role: "columnheader",
+      id: vl(e, n.key),
+      "aria-colspan": n.colSpan && n.colSpan > 1 ? n.colSpan : void 0,
+      "aria-sort": d
+    },
+    isPressed: s
+  };
+}
+function Hr(t, e, l) {
+  let { node: n, isVirtualized: r, shouldSelectOnPressUp: i, onAction: o } = t, { actions: u, shouldSelectOnPressUp: s } = $t.get(e), c = u.onRowAction ? () => u.onRowAction?.(n.key) : o, { itemProps: d, ...a } = cl({
+    selectionManager: e.selectionManager,
+    key: n.key,
+    ref: l,
+    isVirtualized: r,
+    shouldSelectOnPressUp: s || i,
+    onAction: c || n?.props?.onAction ? er(n?.props?.onAction, c) : void 0,
+    isDisabled: e.collection.size === 0
+  }), f = e.selectionManager.isSelected(n.key), p = {
+    role: "row",
+    "aria-selected": e.selectionManager.selectionMode !== "none" ? f : void 0,
+    "aria-disabled": a.isDisabled || void 0,
+    ...d
+  };
+  return r && (p["aria-rowindex"] = n.index + 1), {
+    rowProps: p,
+    ...a
+  };
+}
+function Wr(t) {
+  return t && t.__esModule ? t.default : t;
+}
+const Zt = {
+  expand: {
+    ltr: "ArrowRight",
+    rtl: "ArrowLeft"
+  },
+  collapse: {
+    ltr: "ArrowLeft",
+    rtl: "ArrowRight"
+  }
+};
+function Or(t, e, l) {
+  let { node: n, isVirtualized: r } = t, { rowProps: i, ...o } = Hr(t, e, l), { direction: u } = $e();
+  r && e.treeColumn == null ? i["aria-rowindex"] = n.index + 1 + e.collection.headerRows.length : delete i["aria-rowindex"];
+  let s = e.treeColumn != null && (e.expandedKeys === "all" || e.expandedKeys.has(n.key)), c = Re(Wr(Be), "@react-aria/table"), d = gr({
+    "aria-label": s ? c.format("collapse") : c.format("expand"),
+    "aria-labelledby": ct(e, n.key)
+  }), a = {}, f = {};
+  if (e.treeColumn != null) {
+    let b = e.collection.getItem(n.key);
+    if (b != null) {
+      let C = Jt(e.collection, n), y = b.props?.hasChildRows || b.props?.UNSTABLE_childItems || C?.type !== "cell", g = e.collection.getItem(n.parentKey), m = g.type === "tablebody" || g.type === "body", w = Jt(e.collection, g);
+      for (; w && w.type !== "item" && w.prevKey != null; ) w = e.collection.getItem(w.prevKey);
+      a = {
+        onKeyDown: ($) => {
+          $.key === Zt.expand[u] && e.selectionManager.focusedKey === b.key && y && e.expandedKeys !== "all" && !e.expandedKeys.has(b.key) ? (e.toggleKey(b.key), $.stopPropagation()) : $.key === Zt.collapse[u] && e.selectionManager.focusedKey === b.key && (e.expandedKeys !== "all" ? y && e.expandedKeys.has(b.key) ? (e.toggleKey(b.key), $.stopPropagation()) : !e.expandedKeys.has(b.key) && b.parentKey && b.level > 0 && (e.selectionManager.setFocusedKey(b.parentKey), $.stopPropagation()) : e.expandedKeys === "all" && (e.toggleKey(b.key), $.stopPropagation()));
+        },
+        "aria-expanded": y ? e.expandedKeys === "all" || e.expandedKeys.has(n.key) : void 0,
+        "aria-level": b.level + 1,
+        "aria-posinset": b.index - (m ? 0 : e.collection.columnCount) + 1,
+        "aria-setsize": w.index - (m ? 0 : e.collection.columnCount) + 1
+      }, f = {
+        isDisabled: o.isDisabled,
+        onPress: () => {
+          o.isDisabled || (e.toggleKey(n.key), e.selectionManager.setFocused(!0), e.selectionManager.setFocusedKey(n.key));
+        },
+        excludeFromTabOrder: !0,
+        preventFocusOnPress: !0,
+        // @ts-ignore
+        "data-react-aria-prevent-focus": !0,
+        ...d
+      };
+    }
+  }
+  let p = dr(n.props), h = o.hasAction ? p : {};
+  return {
+    rowProps: {
+      ..._(i, a, h),
+      "aria-labelledby": ct(e, n.key)
+    },
+    expandButtonProps: f,
+    ...o
+  };
+}
+function Jt(t, e) {
+  return "lastChildKey" in e ? e.lastChildKey != null ? t.getItem(e.lastChildKey) : null : Array.from(e.childNodes).findLast((l) => l.parentKey === e.key);
+}
+function jr(t, e, l) {
+  let { node: n, isVirtualized: r } = t, i = {
+    role: "row"
+  };
+  return r && e.treeColumn == null && (i["aria-rowindex"] = n.index + 1), {
+    rowProps: i
+  };
+}
+function _r(t, e, l) {
+  let { gridCellProps: n, isPressed: r } = rn(t, e, l), i = t.node.column?.key;
+  return i != null && e.collection.rowHeaderColumnKeys.has(i) && (n.role = "rowheader", n.id = wl(e, t.node.parentKey, i)), {
+    gridCellProps: n,
+    isPressed: r
+  };
+}
+function Ur(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function Yr(t, e) {
+  let { key: l } = t;
+  const { checkboxProps: n } = Rn(t, e);
+  return {
+    checkboxProps: {
+      ...n,
+      "aria-labelledby": `${n.id} ${ct(e, l)}`
+    }
+  };
+}
+function Xr(t) {
+  let { isEmpty: e, isSelectAll: l, selectionMode: n } = t.selectionManager;
+  return {
+    checkboxProps: {
+      "aria-label": Re(Ur(Be), "@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 Gr(t) {
+  return t && t.__esModule ? t.default : t;
+}
+function qr(t, e, l) {
+  let { column: n, triggerRef: r, isDisabled: i, onResizeStart: o, onResize: u, onResizeEnd: s, "aria-label": c } = t;
+  const d = Re(Gr(Be), "@react-aria/table");
+  let a = yt(), f = e.resizingColumn === n.key, p = K(f), h = K(null), b = K(!1), C = e.tableState.isKeyboardNavigationDisabled, { direction: y } = $e(), g = M((v) => {
+    p.current || (h.current = e.updateResizedColumns(v.key, e.getColumnWidth(v.key)), e.startResize(v.key), e.tableState.setKeyboardNavigationDisabled(!0), o?.(h.current)), p.current = !0;
+  }, [
+    e,
+    o
+  ]), m = M((v, P) => {
+    let W = e.updateResizedColumns(v.key, P);
+    u?.(W), h.current = W;
+  }, [
+    e,
+    u
+  ]), w = M((v) => {
+    p.current && (h.current == null && (h.current = e.updateResizedColumns(v.key, e.getColumnWidth(v.key))), e.endResize(), e.tableState.setKeyboardNavigationDisabled(!1), s?.(h.current), p.current = !1, r?.current && !b.current && le(r.current)), h.current = null;
+  }, [
+    e,
+    r,
+    s
+  ]), { keyboardProps: $ } = pr({
+    onKeyDown: (v) => {
+      C ? (v.key === "Escape" || v.key === "Enter" || v.key === " " || v.key === "Tab") && (v.preventDefault(), w(n)) : (v.continuePropagation(), v.key === "Enter" && g(n));
+    }
+  });
+  const S = K(0), { moveProps: k } = $r({
+    onMoveStart() {
+      S.current = e.getColumnWidth(n.key), g(n);
+    },
+    onMove(v) {
+      let { deltaX: P, deltaY: W, pointerType: ae } = v;
+      y === "rtl" && (P *= -1), ae === "keyboard" && (W !== 0 && P === 0 && (P = W * -1), P *= 10), P !== 0 && (S.current += P, m(n, S.current));
+    },
+    onMoveEnd(v) {
+      let { pointerType: P } = v;
+      S.current = 0, (P === "mouse" || P === "touch" && b.current) && w(n);
+    }
+  });
+  let B = M((v) => {
+    C && k.onKeyDown?.(v);
+  }, [
+    C,
+    k
+  ]), R = Math.floor(e.getColumnMinWidth(n.key)), F = Math.floor(e.getColumnMaxWidth(n.key));
+  F === 1 / 0 && (F = Number.MAX_SAFE_INTEGER);
+  let j = Math.floor(e.getColumnWidth(n.key)), H = cr();
+  H === "virtual" && typeof window < "u" && "ontouchstart" in window && (H = "touch");
+  let U = r?.current == null && (H === "keyboard" || H === "virtual") && !f ? d.format("resizerDescription") : void 0, T = bt(U), I = {
+    "aria-label": c,
+    "aria-orientation": "horizontal",
+    "aria-labelledby": `${a} ${vl(e.tableState, n.key)}`,
+    "aria-valuetext": d.format("columnSize", {
+      value: j
+    }),
+    type: "range",
+    min: R,
+    max: F,
+    value: j,
+    ...T
+  };
+  const L = M(() => {
+    l.current && le(l.current);
+  }, [
+    l
+  ]);
+  let Y = e.resizingColumn, re = K(null), pe = st(g);
+  he(() => {
+    if (re.current !== Y && Y != null && Y === n.key) {
+      b.current = Ge() === l.current, pe(n);
+      let v = setTimeout(() => L(), 0), P = setTimeout(L, 400);
+      return () => {
+        clearTimeout(v), clearTimeout(P);
+      };
+    }
+    re.current = Y;
+  }, [
+    Y,
+    n,
+    L,
+    l
+  ]);
+  let xe = (v) => {
+    let P = e.getColumnWidth(n.key), W = parseFloat(Q(v).value);
+    W > P ? W = P + 10 : W = P - 10, m(n, W);
+  }, { pressProps: ie } = gl({
+    preventFocusOnPress: !0,
+    onPressStart: (v) => {
+      if (!(v.ctrlKey || v.altKey || v.metaKey || v.shiftKey || v.pointerType === "keyboard")) {
+        if (v.pointerType === "virtual" && e.resizingColumn != null) {
+          w(n);
+          return;
+        }
+        L(), v.pointerType !== "virtual" && g(n);
+      }
+    },
+    onPress: (v) => {
+      (v.pointerType === "touch" && b.current || v.pointerType === "mouse") && e.resizingColumn != null && w(n);
+    }
+  }), { visuallyHiddenProps: oe } = nt();
+  return {
+    resizerProps: _($, {
+      ...k,
+      onKeyDown: B
+    }, ie, {
+      style: {
+        touchAction: "none"
+      }
+    }),
+    inputProps: _(oe, {
+      id: a,
+      onBlur: () => {
+        w(n);
+      },
+      onChange: xe,
+      disabled: i
+    }, I),
+    isResizing: f
+  };
+}
+function Zr() {
+  return {
+    rowGroupProps: {
+      role: "rowgroup"
+    }
+  };
+}
+function on() {
+  return Zr();
+}
+function Jr(t) {
+  return t && t.__esModule ? t.default : t;
+}
+class Qr extends Gn {
+  withExpandedKeys(e) {
+    let l = this.clone();
+    return l.expandedKeys = e, l.frozen = this.frozen, l.rows = Array.from(l.getChildren(l.body.key)), l;
+  }
+  addNode(e) {
+    super.addNode(e), this.columnsDirty ||= e.type === "column", e.type === "tableheader" && (this.head = e), e.type === "tablebody" && (this.body = e);
+  }
+  commit(e, l, n = !1) {
+    this.updateColumns(n), this.rows = [];
+    for (let r of this.getChildren(this.body.key)) {
+      let i = r.lastChildKey;
+      if (i != null) {
+        let o = this.getItem(i);
+        for (; o && o.type !== "cell"; ) o = o.prevKey ? this.getItem(o.prevKey) : null;
+        if (o) {
+          let u = (o.colIndex ?? o.index) + (o.colSpan ?? 1);
+          if (u !== this.columns.length && !n) throw new Error(`Cell count must match column count. Found ${u} cells and ${this.columns.length} columns.`);
+        }
+      }
+      this.rows.push(r);
+    }
+    super.commit(e, l, n);
+  }
+  updateColumns(e) {
+    if (!this.columnsDirty) return;
+    this.rowHeaderColumnKeys = /* @__PURE__ */ new Set(), this.columns = [];
+    let l = /* @__PURE__ */ new Map(), n = (r) => {
+      r.type === "column" && (l.set(r.key, r), r.hasChildNodes || (r.index = this.columns.length, this.columns.push(r), r.props.isRowHeader && this.rowHeaderColumnKeys.add(r.key)));
+      for (let i of this.getChildren(r.key)) n(i);
+    };
+    for (let r of this.getChildren(this.head.key)) n(r);
+    if (this.headerRows = $l(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() {
+    let e = this.body.lastChildKey;
+    if (e == null) return null;
+    let l = this.getItem(e);
+    for (; l?.lastChildKey != null && (l.type !== "item" || this.expandedKeys.has(l.key)); ) l = this.getItem(l.lastChildKey);
+    return l?.key;
+  }
+  getKeyAfter(e) {
+    let l = this.getItem(e);
+    if (l?.type === "column") return l.nextKey ?? null;
+    if (!l) return null;
+    if (l.type === "item" && l.firstChildKey != null && this.expandedKeys.has(l.key)) {
+      let n = this.getItem(l.firstChildKey);
+      for (; n; ) {
+        if (n.type === "item") return n.key;
+        n = n.nextKey != null ? this.getItem(n.nextKey) : null;
+      }
+    }
+    return super.getKeyAfter(e);
+  }
+  getKeyBefore(e) {
+    let l = this.getItem(e);
+    if (l?.type === "column") return l.prevKey ?? null;
+    if (!l) return null;
+    let n = null;
+    if (l.prevKey != null) {
+      for (l = this.getItem(l.prevKey); l && (l.type !== "item" || this.expandedKeys.has(l.key)) && l.lastChildKey != null; ) l = this.getItem(l.lastChildKey);
+      n = l?.key ?? null;
+    }
+    return n == null && (n = l.parentKey), n != null && this.getItem(n)?.type === "tablebody" ? null : n;
+  }
+  getChildren(e) {
+    if (!this.getItem(e)) {
+      for (let n of this.headerRows)
+        if (n.key === e) return n.childNodes;
+    }
+    let l = this;
+    return e === this.body.key ? {
+      *[Symbol.iterator]() {
+        let n = l.getFirstKey(), r = n != null ? l.getItem(n) : null;
+        for (; r; ) {
+          yield r;
+          let i = l.getKeyAfter(r.key);
+          r = i ? l.getItem(i) : null;
+        }
+      }
+    } : {
+      *[Symbol.iterator]() {
+        let n = l.getItem(e), r = n?.firstChildKey != null ? l.getItem(n.firstChildKey) : null;
+        for (; r && (yield r, r = r.nextKey != null ? l.getItem(r.nextKey) : null, !(n?.type === "item" && r?.type !== "cell")); )
+          ;
+      }
+    };
+  }
+  clone() {
+    let e = super.clone();
+    return e.headerRows = this.headerRows, e.columns = this.columns, e.rows = this.rows, 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, r = [];
+    for (let i of this.getChildren(e)) {
+      let o = this.columns[i.index];
+      if (n.has(o.key) && i.textValue && r.push(i.textValue), r.length === n.size) break;
+    }
+    return r.join(" ");
+  }
+  constructor(...e) {
+    super(...e), this.headerRows = [], this.columns = [], this.rows = [], this.rowHeaderColumnKeys = /* @__PURE__ */ new Set(), this.head = new Je(-1), this.body = new Qe(-2), this.columnsDirty = !0, this.expandedKeys = /* @__PURE__ */ new Set();
+  }
+}
+const vt = /* @__PURE__ */ ge(null), ei = /* @__PURE__ */ J(function(e, l) {
+  let n = ee(l), r = K(null), i = K(null), [o, u] = Z(0);
+  _t(() => {
+    let c = r.current;
+    for (; c && c !== n.current && !Zn(c); ) c = c.parentElement;
+    i.current = c;
+  }, [
+    n
+  ]), nr({
+    ref: i,
+    box: "border-box",
+    onResize() {
+      u(i.current?.clientWidth ?? 0);
+    }
+  }), _t(() => {
+    u(i.current?.clientWidth ?? 0);
+  }, []);
+  let s = A(() => ({
+    tableRef: r,
+    scrollRef: i,
+    tableWidth: o,
+    useTableColumnResizeState: Pr,
+    onResizeStart: e.onResizeStart,
+    onResize: e.onResize,
+    onResizeEnd: e.onResizeEnd
+  }), [
+    r,
+    o,
+    e.onResizeStart,
+    e.onResize,
+    e.onResizeEnd
+  ]);
+  return /* @__PURE__ */ D.createElement(N.div, {
+    render: e.render,
+    ...ne(e, {
+      global: !0
+    }),
+    ref: n,
+    className: e.className || "react-aria-ResizableTableContainer",
+    style: e.style,
+    onScroll: e.onScroll
+  }, /* @__PURE__ */ D.createElement(vt.Provider, {
+    value: s
+  }, e.children));
+}), ti = /* @__PURE__ */ ge(null), de = /* @__PURE__ */ ge(null), wt = /* @__PURE__ */ ge(null), li = /* @__PURE__ */ J(function(e, l) {
+  [e, l] = ul(e, l, ti);
+  let n = dl(e), { selectionBehavior: r, selectionMode: i, disallowEmptySelection: o } = n, u = !!e.dragAndDropHooks?.useDraggableCollectionState, s = A(() => ({
+    selectionBehavior: i === "none" ? null : r,
+    selectionMode: i,
+    disallowEmptySelection: o,
+    allowsDragging: u
+  }), [
+    r,
+    i,
+    o,
+    u
+  ]), c = /* @__PURE__ */ D.createElement(an.Provider, {
+    value: s
+  }, /* @__PURE__ */ D.createElement(He, e));
+  return /* @__PURE__ */ D.createElement(Yn, {
+    content: c,
+    createCollection: () => new Qr()
+  }, (d) => /* @__PURE__ */ D.createElement(ri, {
+    props: e,
+    forwardedRef: l,
+    selectionState: n,
+    collection: d
+  }));
+});
+let ni = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.table, {
+    ...e,
+    ref: l
+  });
+});
+const Qt = {
+  expand: {
+    ltr: "ArrowRight",
+    rtl: "ArrowLeft"
+  },
+  collapse: {
+    ltr: "ArrowLeft",
+    rtl: "ArrowRight"
+  }
+};
+function ri({ props: t, forwardedRef: e, selectionState: l, collection: n }) {
+  [t, e] = ul(t, e, Ot);
+  let { shouldUseVirtualFocus: r, disallowTypeAhead: i, filter: o, ...u } = t, s = E(vt);
+  e = ee(A(() => tr(e, s?.tableRef), [
+    e,
+    s?.tableRef
+  ]));
+  let [c, d] = ml(t.expandedKeys ? new Set(t.expandedKeys) : void 0, t.defaultExpandedKeys ? new Set(t.defaultExpandedKeys) : /* @__PURE__ */ new Set(), t.onExpandedChange);
+  n = A(() => n.withExpandedKeys(c), [
+    n,
+    c
+  ]);
+  let a = Rr({
+    ...u,
+    collection: n,
+    children: void 0,
+    UNSAFE_selectionState: l,
+    expandedKeys: c,
+    onExpandedChange: d
+  }), f = Tr(a, o), { isVirtualized: p, layoutDelegate: h, dropTargetDelegate: b, CollectionRoot: C } = E(V), { dragAndDropHooks: y } = t, { gridProps: g } = Nr({
+    ...u,
+    layoutDelegate: h,
+    isVirtualized: p
+  }, f, e), m = f.selectionManager, w = !!y?.useDraggableCollectionState, $ = !!y?.useDroppableCollectionState, S = K(w), k = K($);
+  he(() => {
+    process.env.NODE_ENV !== "production" && (S.current !== w && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), k.current !== $ && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."));
+  }, [
+    w,
+    $
+  ]);
+  let B, R, F, j = !1, H = null, U = K(null), { direction: T } = $e(), [I] = Z(() => new Cr());
+  if (w && y) {
+    B = y.useDraggableCollectionState({
+      collection: f.collection,
+      selectionManager: m,
+      preview: y.renderDragPreview ? U : void 0
+    }), y.useDraggableCollection({}, B, e);
+    let P = y.DragPreview;
+    H = y.renderDragPreview ? /* @__PURE__ */ D.createElement(P, {
+      ref: U
+    }, y.renderDragPreview) : null;
+  }
+  if ($ && y) {
+    R = y.useDroppableCollectionState({
+      collection: f.collection,
+      selectionManager: m
+    });
+    let P = new Qn({
+      collection: f.collection,
+      disabledKeys: m.disabledKeys,
+      disabledBehavior: m.disabledBehavior,
+      ref: e,
+      layoutDelegate: h
+    }), W = y.dropTargetDelegate || b || new y.ListDropTargetDelegate(n.rows, e);
+    I.setup(W, a, T), F = y.useDroppableCollection({
+      keyboardDelegate: P,
+      dropTargetDelegate: I,
+      onDropActivate: (ae) => {
+        if (ae.target.type === "item") {
+          let X = ae.target.key, te = a.collection.getItem(X), Ce = c.has(X);
+          te && te.hasChildNodes && (!Ce || y?.isVirtualDragging?.()) && a.toggleKey(X);
+        }
+      },
+      onKeyDown: (ae) => {
+        let X = R?.target;
+        if (X && X.type === "item" && X.dropPosition === "on") {
+          let te = a.collection.getItem(X.key);
+          (ae.key === Qt.expand[T] && te?.hasChildNodes && !a.expandedKeys.has(X.key) || ae.key === Qt.collapse[T] && te?.hasChildNodes && a.expandedKeys.has(X.key)) && a.toggleKey(X.key);
+        }
+      }
+    }, R, e), j = R.isDropTarget({
+      type: "root"
+    });
+  }
+  let { focusProps: L, isFocused: Y, isFocusVisible: re } = Ke(), pe = be({
+    ...t,
+    children: void 0,
+    defaultClassName: "react-aria-Table",
+    values: {
+      isDropTarget: j,
+      isFocused: Y,
+      isFocusVisible: re,
+      state: f
+    }
+  }), xe = !!(w && !B?.isDisabled), ie = pe.style, oe = null;
+  s && (oe = s.useTableColumnResizeState({
+    tableWidth: s.tableWidth
+  }, f), p || (ie = {
+    ...ie,
+    tableLayout: "fixed",
+    // due to https://bugzilla.mozilla.org/show_bug.cgi?id=1959353, we can't use "fit-content".
+    // Causes the table columns to grow to fill the available space in Firefox, ignoring user set column widths
+    width: "min-content"
+  }));
+  let v = ne(t, {
+    global: !0
+  });
+  return /* @__PURE__ */ D.createElement(tt, {
+    values: [
+      [
+        de,
+        f
+      ],
+      [
+        wt,
+        oe
+      ],
+      [
+        Ae,
+        {
+          dragAndDropHooks: y,
+          dragState: B,
+          dropState: R
+        }
+      ],
+      [
+        Ln,
+        {
+          render: hi
+        }
+      ],
+      [
+        Ot,
+        null
+      ],
+      [
+        Wn,
+        null
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(qn, null, /* @__PURE__ */ D.createElement(ni, {
+    ..._(v, pe, g, L, F?.collectionProps),
+    style: ie,
+    ref: e,
+    slot: t.slot || void 0,
+    onScroll: t.onScroll,
+    "data-allows-dragging": xe || void 0,
+    "data-drop-target": j || void 0,
+    "data-focused": Y || void 0,
+    "data-focus-visible": re || void 0
+  }, /* @__PURE__ */ D.createElement(_n, null, /* @__PURE__ */ D.createElement(C, {
+    collection: f.collection,
+    scrollRef: s?.scrollRef ?? e,
+    persistedKeys: Hn(m, y, R)
+  })))), H);
+}
+const an = /* @__PURE__ */ ge(null);
+function sn() {
+  return E(an);
+}
+const Kt = class Kt extends lt {
+};
+Kt.type = "tableheader";
+let Je = Kt, ii = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.thead, {
+    ...e,
+    ref: l
+  });
+});
+const oi = /* @__PURE__ */ gt(Je, (t, e) => {
+  let l = E(de).collection, n = Un({
+    items: l.headerRows,
+    children: M((s) => {
+      if (s.type === "headerrow")
+        return /* @__PURE__ */ D.createElement(si, {
+          item: s
+        });
+      throw new Error("Unsupported node type in TableHeader: " + s.type);
+    }, [])
+  }), { rowGroupProps: r } = on(), { hoverProps: i, isHovered: o } = We({
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), u = be({
+    ...t,
+    children: void 0,
+    defaultClassName: "react-aria-TableHeader",
+    values: {
+      isHovered: o
+    }
+  });
+  return /* @__PURE__ */ D.createElement(ii, {
+    ..._(ne(t, {
+      global: !0
+    }), r, i),
+    ...u,
+    ref: e,
+    "data-hovered": o || void 0
+  }, n);
+}, (t) => /* @__PURE__ */ D.createElement(He, {
+  dependencies: t.dependencies,
+  items: t.columns
+}, t.children));
+let ai = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement("div", {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement("tr", {
+    ...e,
+    ref: l
+  });
+});
+function si({ item: t }) {
+  let e = K(null), l = E(de), { isVirtualized: n, CollectionBranch: r } = E(V), { rowProps: i } = jr({
+    node: t,
+    isVirtualized: n
+  }, l, e), { checkboxProps: o } = Xr(l);
+  return /* @__PURE__ */ D.createElement(ai, {
+    ...i,
+    ref: e
+  }, /* @__PURE__ */ D.createElement(tt, {
+    values: [
+      [
+        al,
+        {
+          slots: {
+            selection: o
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(r, {
+    collection: l.collection,
+    parent: t
+  })));
+}
+const At = class At extends lt {
+};
+At.type = "column";
+let ft = At, ui = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.th, {
+    ...e,
+    ref: l
+  });
+});
+const di = /* @__PURE__ */ pl(ft, (t, e, l) => {
+  let n = ee(e), r = E(de), { isVirtualized: i } = E(V), { columnHeaderProps: o, isPressed: u } = Lr({
+    node: l,
+    isVirtualized: i
+  }, r, n), { isFocused: s, isFocusVisible: c, focusProps: d } = Ke(), a = E(wt), f = !1;
+  if (a) f = a.resizingColumn === l.key;
+  else if (process.env.NODE_ENV !== "production")
+    for (let g in [
+      "width",
+      "defaultWidth",
+      "minWidth",
+      "maxWidth"
+    ]) g in l.props && console.warn(`The ${g} 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: p, isHovered: h } = We({
+    isDisabled: !t.allowsSorting
+  }), b = be({
+    ...t,
+    id: void 0,
+    children: l.rendered,
+    defaultClassName: "react-aria-Column",
+    values: {
+      isHovered: h,
+      isPressed: u,
+      isFocused: s,
+      isFocusVisible: c,
+      allowsSorting: l.props.allowsSorting,
+      sortDirection: r.sortDescriptor?.column === l.key ? r.sortDescriptor.direction : void 0,
+      isResizing: f,
+      startResize: () => {
+        if (a)
+          a.startResize(l.key), r.setKeyboardNavigationDisabled(!0);
+        else throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+      },
+      sort: (g) => {
+        r.sort(l.key, g);
+      }
+    }
+  }), C = b.style;
+  a && (C = {
+    ...C,
+    width: a.getColumnWidth(l.key)
+  });
+  let y = ne(t, {
+    global: !0
+  });
+  return delete y.id, /* @__PURE__ */ D.createElement(ui, {
+    ..._(y, o, d, p),
+    ...b,
+    style: C,
+    ref: n,
+    "data-hovered": h || void 0,
+    "data-pressed": u || void 0,
+    "data-focused": s || void 0,
+    "data-focus-visible": c || void 0,
+    "data-resizing": f || void 0,
+    "data-allows-sorting": l.props.allowsSorting || void 0,
+    "data-sort-direction": r.sortDescriptor?.column === l.key ? r.sortDescriptor.direction : void 0
+  }, /* @__PURE__ */ D.createElement(tt, {
+    values: [
+      [
+        un,
+        {
+          column: l,
+          triggerRef: n
+        }
+      ],
+      [
+        V,
+        fl
+      ]
+    ]
+  }, b.children));
+}), un = /* @__PURE__ */ ge(null), ci = /* @__PURE__ */ J(function(e, l) {
+  let n = E(wt);
+  if (!n) throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
+  let r = Re(Jr(On), "react-aria-components"), { onResizeStart: i, onResize: o, onResizeEnd: u } = E(vt), { column: s, triggerRef: c } = E(un), d = K(null), { resizerProps: a, inputProps: f, isResizing: p } = qr({
+    column: s,
+    "aria-label": e["aria-label"] || r.format("tableResizer"),
+    onResizeStart: i,
+    onResize: o,
+    onResizeEnd: u,
+    triggerRef: c
+  }, n, d), { focusProps: h, isFocused: b, isFocusVisible: C } = Ke(), { hoverProps: y, isHovered: g } = We(e), m = n.getColumnMinWidth(s.key) >= n.getColumnWidth(s.key), w = n.getColumnMaxWidth(s.key) <= n.getColumnWidth(s.key), { direction: $ } = $e(), S = "both";
+  m ? S = $ === "rtl" ? "right" : "left" : w ? S = $ === "rtl" ? "left" : "right" : S = "both";
+  let k = ee(l), [B, R] = Z("");
+  he(() => {
+    if (!k.current) return;
+    let I = window.getComputedStyle(k.current);
+    R(I.cursor);
+  }, [
+    k,
+    S
+  ]);
+  let F = be({
+    ...e,
+    defaultClassName: "react-aria-ColumnResizer",
+    values: {
+      isFocused: b,
+      isFocusVisible: C,
+      isResizing: p,
+      isHovered: g,
+      resizableDirection: S
+    }
+  }), [j, H] = Z(!1), U = (I) => {
+    I.pointerType === "mouse" && H(!0);
+  };
+  !p && j && H(!1);
+  let T = ne(e, {
+    global: !0
+  });
+  return /* @__PURE__ */ D.createElement(N.div, {
+    ref: k,
+    role: "presentation",
+    ..._(T, F, a, {
+      onPointerDown: U
+    }, y),
+    "data-hovered": g || void 0,
+    "data-focused": b || void 0,
+    "data-focus-visible": C || void 0,
+    "data-resizing": p || void 0,
+    "data-resizable-direction": S
+  }, F.children, /* @__PURE__ */ D.createElement("input", {
+    ref: d,
+    ..._(f, h)
+  }), p && j && /* @__PURE__ */ lr.createPortal(/* @__PURE__ */ D.createElement("div", {
+    style: {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      bottom: 0,
+      right: 0,
+      cursor: B
+    }
+  }), document.body));
+}), Rt = class Rt extends Xn {
+};
+Rt.type = "tablebody";
+let Qe = Rt, fi = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.tbody, {
+    ...e,
+    ref: l
+  });
+});
+const pi = /* @__PURE__ */ gt(Qe, (t, e) => {
+  let l = E(de), { isVirtualized: n } = E(V), r = l.collection, { CollectionBranch: i } = E(V), { dragAndDropHooks: o, dropState: u } = E(Ae), s = !!o?.useDroppableCollectionState && !u?.isDisabled, c = s && !!u && (u.isDropTarget({
+    type: "root"
+  }) ?? !1), d = r.size === 0, a = {
+    isDropTarget: c,
+    isEmpty: d
+  }, f = be({
+    ...t,
+    id: void 0,
+    children: void 0,
+    defaultClassName: "react-aria-TableBody",
+    values: a
+  }), p, h = r.columnCount;
+  if (d && t.renderEmptyState && l) {
+    let y = {}, g = {}, m = {};
+    n ? (g["aria-colspan"] = h, m = {
+      display: "contents"
+    }) : g.colSpan = h, p = /* @__PURE__ */ D.createElement(et, {
+      role: "row",
+      ...y,
+      style: m
+    }, /* @__PURE__ */ D.createElement(rt, {
+      role: "rowheader",
+      ...g,
+      style: m
+    }, t.renderEmptyState(a)));
+  }
+  let { rowGroupProps: b } = on(), C = ne(t, {
+    global: !0
+  });
+  return /* @__PURE__ */ D.createElement(fi, {
+    ..._(C, f, b),
+    ref: e,
+    "data-empty": d || void 0
+  }, s && /* @__PURE__ */ D.createElement($i, null), /* @__PURE__ */ D.createElement(i, {
+    collection: r,
+    parent: r.body,
+    renderDropIndicator: Vn(o, u)
+  }), p);
+}), Tt = class Tt extends lt {
+  filter(e, l, n) {
+    let r = e.getChildren(this.key);
+    for (let i of r) if (n(i.textValue, i)) {
+      let o = this.clone();
+      return l.addDescendants(o, e), o;
+    }
+    return null;
+  }
+};
+Tt.type = "item";
+let pt = Tt, et = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.tr, {
+    ...e,
+    ref: l
+  });
+});
+const el = /* @__PURE__ */ gt(pt, (t, e, l) => {
+  let n = ee(e), r = E(de), { dragAndDropHooks: i, dragState: o, dropState: u } = E(Ae), { isVirtualized: s, CollectionBranch: c } = E(V), { rowProps: d, expandButtonProps: a, ...f } = Or({
+    node: l,
+    shouldSelectOnPressUp: !!o,
+    isVirtualized: s
+  }, r, n), { isFocused: p, isFocusVisible: h, focusProps: b } = Ke(), { isFocusVisible: C, focusProps: y } = Ke({
+    within: !0
+  }), { hoverProps: g, isHovered: m } = We({
+    isDisabled: !f.allowsSelection && !f.hasAction,
+    onHoverStart: t.onHoverStart,
+    onHoverChange: t.onHoverChange,
+    onHoverEnd: t.onHoverEnd
+  }), { checkboxProps: w } = Yr({
+    key: l.key
+  }, r), $;
+  o && i && ($ = i.useDraggableItem({
+    key: l.key,
+    hasDragButton: !0
+  }, o));
+  let S, k = K(null), { visuallyHiddenProps: B } = nt();
+  u && i && (S = i.useDropIndicator({
+    target: {
+      type: "item",
+      key: l.key,
+      dropPosition: "on"
+    }
+  }, u, k));
+  let R = K(null);
+  he(() => {
+    o && !R.current && process.env.NODE_ENV !== "production" && console.warn('Draggable items in a Table must contain a <Button slot="drag"> element so that keyboard and screen reader users can drag them.');
+  }, []);
+  let F = o && o.isDragging(l.key), { children: j, ...H } = t, U = t.hasChildItems || r.collection.getItem(l.lastChildKey)?.type !== "cell", T = U && r.expandedKeys.has(l.key), I = be({
+    ...H,
+    id: void 0,
+    defaultClassName: "react-aria-Row",
+    defaultStyle: {
+      // @ts-ignore
+      "--table-row-level": l.level + 1
+    },
+    values: {
+      ...f,
+      isHovered: m,
+      isFocused: p,
+      isFocusVisible: h,
+      selectionMode: r.selectionManager.selectionMode,
+      selectionBehavior: r.selectionManager.selectionBehavior,
+      isDragging: F,
+      isDropTarget: S?.isDropTarget,
+      isFocusVisibleWithin: C,
+      id: l.key,
+      hasChildItems: U,
+      isExpanded: T,
+      level: l.level + 1
+    }
+  }), L = ne(t, {
+    global: !0
+  });
+  return delete L.id, delete L.onClick, /* @__PURE__ */ D.createElement(D.Fragment, null, S && !S.isHidden && /* @__PURE__ */ D.createElement(et, {
+    role: "row",
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ D.createElement(rt, {
+    role: "gridcell",
+    colSpan: r.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    role: "button",
+    ...B,
+    ...S.dropIndicatorProps,
+    ref: k
+  }))), /* @__PURE__ */ D.createElement(et, {
+    ..._(L, I, d, b, g, $?.dragProps, y),
+    ref: n,
+    "data-disabled": f.isDisabled || void 0,
+    "data-selected": f.isSelected || void 0,
+    "data-hovered": m || void 0,
+    "data-focused": f.isFocused || void 0,
+    "data-focus-visible": h || void 0,
+    "data-pressed": f.isPressed || void 0,
+    "data-dragging": F || void 0,
+    "data-drop-target": S?.isDropTarget || void 0,
+    "data-selection-mode": r.selectionManager.selectionMode === "none" ? void 0 : r.selectionManager.selectionMode,
+    "data-focus-visible-within": C || void 0,
+    "data-expanded": T || void 0,
+    "data-has-child-items": U || void 0,
+    "data-level": l.level + 1
+  }, /* @__PURE__ */ D.createElement(tt, {
+    values: [
+      [
+        al,
+        {
+          slots: {
+            [Wt]: {},
+            selection: w
+          }
+        }
+      ],
+      [
+        ol,
+        {
+          slots: {
+            [Wt]: {},
+            chevron: a,
+            drag: {
+              ...$?.dragButtonProps,
+              ref: R,
+              style: {
+                pointerEvents: "none"
+              }
+            }
+          }
+        }
+      ],
+      [
+        jn,
+        {
+          isSelected: f.isSelected
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ D.createElement(c, {
+    collection: r.collection,
+    parent: l
+  }))));
+}, (t) => {
+  if (t.id == null && typeof t.children == "function") throw new Error("No id detected for the Row element. The Row element requires a id to be provided to it when the cells are rendered dynamically.");
+  let e = [
+    t.value
+  ].concat(t.dependencies);
+  return /* @__PURE__ */ D.createElement(He, {
+    dependencies: e,
+    items: t.columns,
+    idScope: t.id
+  }, t.children);
+}), Bt = class Bt extends lt {
+};
+Bt.type = "cell";
+let mt = Bt, rt = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.td, {
+    ...e,
+    ref: l
+  });
+});
+const mi = /* @__PURE__ */ pl(mt, (t, e, l) => {
+  let n = ee(e), r = E(de), { dragState: i } = E(Ae), { isVirtualized: o } = E(V);
+  l.column = r.collection.columns[l.index];
+  let { gridCellProps: u, isPressed: s } = _r({
+    node: l,
+    shouldSelectOnPressUp: !!i,
+    isVirtualized: o
+  }, r, n), { isFocused: c, isFocusVisible: d, focusProps: a } = Ke(), { hoverProps: f, isHovered: p } = We({}), h = l.parentKey != null ? r.selectionManager.isSelected(l.parentKey) : !1, b = l.colIndex || l.index, C = r.collection.getItem(l.parentKey), y = C.props.hasChildItems || r.collection.getItem(C.lastChildKey)?.type !== "cell", g = y && r.expandedKeys.has(l.parentKey), m = r.selectionManager.isDisabled(l.parentKey), w = be({
+    ...t,
+    id: void 0,
+    defaultClassName: "react-aria-Cell",
+    values: {
+      isFocused: c,
+      isFocusVisible: d,
+      isPressed: s,
+      isHovered: p,
+      isSelected: h,
+      id: l.key,
+      columnIndex: b,
+      hasChildItems: y,
+      isExpanded: g,
+      isDisabled: m,
+      level: C.level + 1,
+      isTreeColumn: l.column.key === r.treeColumn
+    }
+  }), $ = ne(t, {
+    global: !0
+  });
+  return delete $.id, /* @__PURE__ */ D.createElement(rt, {
+    ..._($, w, u, a, f),
+    ref: n,
+    "data-focused": c || void 0,
+    "data-focus-visible": d || void 0,
+    "data-pressed": s || void 0,
+    "data-selected": h || void 0,
+    "data-column-index": b,
+    "data-expanded": g || void 0,
+    "data-has-child-items": y || void 0,
+    "data-level": C.level + 1,
+    "data-tree-column": l.column.key === r.treeColumn || void 0,
+    "data-disabled": m || void 0
+  }, /* @__PURE__ */ D.createElement(V.Provider, {
+    value: fl
+  }, w.children));
+});
+function hi(t, e) {
+  e = ee(e);
+  let { dragAndDropHooks: l, dropState: n } = E(Ae), r = K(null), { dropIndicatorProps: i, isHidden: o, isDropTarget: u } = l.useDropIndicator(t, n, r);
+  if (o) return null;
+  let s = n && t.target.type === "item" ? (n.collection.getItem(t.target.key)?.level || 0) + 1 : 1;
+  return /* @__PURE__ */ D.createElement(xi, {
+    ...t,
+    dropIndicatorProps: i,
+    isDropTarget: u,
+    buttonRef: r,
+    level: s,
+    ref: e
+  });
+}
+let gi = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.tr, {
+    ...e,
+    ref: l
+  });
+}), bi = /* @__PURE__ */ J(function(e, l) {
+  let { isVirtualized: n } = E(V);
+  return n ? /* @__PURE__ */ D.createElement(N.div, {
+    ...e,
+    ref: l
+  }) : /* @__PURE__ */ D.createElement(N.td, {
+    ...e,
+    ref: l
+  });
+});
+function yi(t, e) {
+  let { dropIndicatorProps: l, isDropTarget: n, buttonRef: r, level: i, ...o } = t, u = E(de), { visuallyHiddenProps: s } = nt(), c = be({
+    ...o,
+    defaultClassName: "react-aria-DropIndicator",
+    defaultStyle: {
+      // @ts-ignore
+      "--table-row-level": i + 1
+    },
+    values: {
+      isDropTarget: n
+    }
+  });
+  return /* @__PURE__ */ D.createElement(gi, {
+    ...ne(t, {
+      global: !0
+    }),
+    ...c,
+    role: "row",
+    ref: e,
+    "data-drop-target": n || void 0,
+    "aria-level": i
+  }, /* @__PURE__ */ D.createElement(bi, {
+    role: "gridcell",
+    colSpan: u.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    ...s,
+    role: "button",
+    ...l,
+    ref: r
+  }), c.children));
+}
+const xi = /* @__PURE__ */ J(yi);
+function $i() {
+  let t = E(de), { dragAndDropHooks: e, dropState: l } = E(Ae), n = K(null), { dropIndicatorProps: r } = e.useDropIndicator({
+    target: {
+      type: "root"
+    }
+  }, l, n), i = l.isDropTarget({
+    type: "root"
+  }), { visuallyHiddenProps: o } = nt();
+  return !i && r["aria-hidden"] ? null : /* @__PURE__ */ D.createElement(et, {
+    role: "row",
+    "aria-hidden": r["aria-hidden"],
+    style: {
+      height: 0
+    }
+  }, /* @__PURE__ */ D.createElement(rt, {
+    role: "gridcell",
+    colSpan: t.collection.columnCount,
+    style: {
+      padding: 0
+    }
+  }, /* @__PURE__ */ D.createElement("div", {
+    role: "button",
+    ...o,
+    ...r,
+    ref: n
+  })));
+}
+const { withProvider: Ci, withContext: ce } = /* @__PURE__ */ In({
+  key: "nimbusDataTable"
+}), vi = /* @__PURE__ */ Ci("div", "root"), wi = /* @__PURE__ */ ce("table", "table"), Di = /* @__PURE__ */ ce("tr", "header"), Si = /* @__PURE__ */ ce("th", "column"), ki = /* @__PURE__ */ ce("tbody", "body"), tl = /* @__PURE__ */ ce("tr", "row"), Ei = /* @__PURE__ */ ce("td", "cell"), zi = /* @__PURE__ */ ce("footer", "footer"), Pi = /* @__PURE__ */ ce("span", "headerSortIcon"), Ki = /* @__PURE__ */ ce("div", "columnResizer"), it = /* @__PURE__ */ ge(null);
+it.displayName = "DataTable.Context";
+const Dt = /* @__PURE__ */ ge(null);
+Dt.displayName = "CustomSettings.Context";
+const ye = () => {
+  const t = E(
+    it
+  );
+  if (!t)
+    throw new Error("DataTable components must be used within DataTable.Root");
+  return t;
+}, Ai = () => {
+  const t = E(Dt);
+  if (!t)
+    throw new Error(
+      "CustomSettings components must be used within CustomSettings.Root"
+    );
+  return t;
+};
+function dn(t, e, l, n) {
+  if (!e) return t;
+  const r = e.toLowerCase();
+  return t.map((i) => {
+    const o = l.some((u) => {
+      const s = u.accessor(i);
+      return typeof s == "string" && s.toLowerCase().includes(r);
+    });
+    if (n && i[n]) {
+      let u = i[n];
+      if (Array.isArray(i[n])) {
+        if (u = dn(
+          i[n],
+          e,
+          l,
+          n
+        ), o || u && Array.isArray(u) && u.length > 0)
+          return { ...i, [n]: u };
+      } else if (o)
+        return { ...i, [n]: u };
+      return null;
+    } else
+      return o ? i : null;
+  }).filter(Boolean);
+}
+function cn(t, e, l, n, r) {
+  const i = [], o = [];
+  t.forEach((c) => {
+    r?.has(c.id) ? i.push(c) : o.push(c);
+  });
+  let u = o;
+  if (e) {
+    const c = l.find((d) => d.id === e.column);
+    c && (u = [...o].sort((d, a) => {
+      const f = c.accessor(d), p = c.accessor(a);
+      if (f == null && p == null) return 0;
+      if (f == null) return 1;
+      if (p == null) return -1;
+      const h = typeof f == "number" && typeof p == "number" ? f : String(f).toLowerCase(), b = typeof f == "number" && typeof p == "number" ? p : String(p).toLowerCase();
+      return h < b ? e.direction === "ascending" ? -1 : 1 : h > b ? e.direction === "ascending" ? 1 : -1 : 0;
+    }));
+  }
+  return [...i, ...u].map((c) => !n || !c[n] ? c : {
+    ...c,
+    [n]: Array.isArray(c[n]) ? cn(
+      c[n],
+      e,
+      l,
+      n,
+      r
+    ) : c[n]
+  });
+}
+function fn(t, e) {
+  return e ? t.some(
+    (l) => l[e] && (Array.isArray(l[e]) ? l[e].length > 0 : !0) || Array.isArray(l[e]) && fn(l[e], e)
+  ) : !1;
+}
+const St = function(e) {
+  const {
+    ref: l,
+    columns: n = [],
+    rows: r = [],
+    visibleColumns: i,
+    search: o,
+    sortDescriptor: u,
+    defaultSortDescriptor: s,
+    onSortChange: c,
+    selectedKeys: d,
+    defaultSelectedKeys: a,
+    onSelectionChange: f,
+    selectionMode: p = "none",
+    disallowEmptySelection: h = !1,
+    allowsSorting: b = !1,
+    maxHeight: C,
+    isTruncated: y = !1,
+    density: g = "default",
+    nestedKey: m,
+    onRowClick: w,
+    onDetailsClick: $,
+    disabledKeys: S,
+    onRowAction: k,
+    isResizable: B,
+    expandedRows: R,
+    defaultExpandedRows: F,
+    onExpandRowsChange: j,
+    pinnedRows: H,
+    defaultPinnedRows: U,
+    onPinToggle: T,
+    onColumnsChange: I,
+    onSettingsChange: L,
+    customSettings: Y,
+    children: re,
+    ...pe
+  } = e, xe = K(null), ie = ee(Le(xe, l)), [oe, v] = Z(s), [P, W] = Z(
+    () => F || /* @__PURE__ */ new Set()
+  ), [ae, X] = Z(
+    () => U || /* @__PURE__ */ new Set()
+  ), te = u ?? oe, Ce = R ?? P, Oe = H ?? ae, ve = A(() => {
+    if (!i)
+      return n;
+    const q = new Map(n.map((G) => [G.id, G]));
+    return i.map((G) => q.get(G)).filter((G) => G !== void 0);
+  }, [n, i]), je = A(
+    () => o ? dn(r, o, ve, m) : r,
+    [r, o, ve, m]
+  ), ot = A(
+    () => cn(
+      je,
+      te,
+      ve,
+      m,
+      Oe
+    ),
+    [je, te, ve, m, Oe]
+  ), It = fn(ot, m), Mt = p !== "none", Ft = M(
+    (q) => {
+      const G = new Set(Ce);
+      G.has(q) ? G.delete(q) : G.add(q), j?.(G), R === void 0 && W(G);
+    },
+    [Ce, j, R]
+  ), Nt = M(
+    (q) => {
+      T ? T(q) : X((G) => {
+        const _e = new Set(G);
+        return _e.has(q) ? _e.delete(q) : _e.add(q), _e;
+      });
+    },
+    [T]
+  ), Vt = M(
+    (q) => {
+      c ? c(q) : v(q);
+    },
+    [c]
+  ), hn = A(
+    () => ({
+      columns: n,
+      rows: r,
+      visibleColumns: i,
+      search: o,
+      sortDescriptor: te,
+      selectedKeys: d,
+      defaultSelectedKeys: a,
+      expanded: Ce,
+      allowsSorting: b,
+      selectionMode: p,
+      disallowEmptySelection: h,
+      maxHeight: C,
+      isTruncated: y,
+      density: g,
+      nestedKey: m,
+      onSortChange: Vt,
+      onSelectionChange: f,
+      onRowClick: w,
+      onDetailsClick: $,
+      toggleExpand: Ft,
+      activeColumns: ve,
+      filteredRows: je,
+      sortedRows: ot,
+      showExpandColumn: It,
+      showSelectionColumn: Mt,
+      isResizable: B,
+      disabledKeys: S,
+      onRowAction: k,
+      pinnedRows: Oe,
+      onPinToggle: T,
+      togglePin: Nt,
+      onColumnsChange: I,
+      onSettingsChange: L
+    }),
+    [
+      n,
+      r,
+      i,
+      o,
+      te,
+      d,
+      a,
+      Ce,
+      b,
+      p,
+      h,
+      C,
+      y,
+      g,
+      m,
+      Vt,
+      f,
+      w,
+      $,
+      Ft,
+      ve,
+      je,
+      ot,
+      It,
+      Mt,
+      B,
+      S,
+      k,
+      Oe,
+      T,
+      Nt,
+      I,
+      L
+    ]
+  ), gn = A(
+    () => ({
+      customSettings: Y
+    }),
+    [Y]
+  );
+  return /* @__PURE__ */ x(
+    vi,
+    {
+      ref: ie,
+      truncated: y,
+      density: g,
+      maxH: C,
+      ...pe,
+      asChild: !0,
+      children: /* @__PURE__ */ x(ei, { children: /* @__PURE__ */ x(
+        it.Provider,
+        {
+          value: hn,
+          children: /* @__PURE__ */ x(Dt.Provider, { value: gn, children: re })
+        }
+      ) })
+    }
+  );
+};
+St.displayName = "DataTable.Root";
+const Ri = {
+  comfortable: "Comfortable",
+  comfortableAriaLabel: "Comfortable section",
+  compact: "Compact",
+  compactAriaLabel: "Compact section",
+  dataTable: "Data table",
+  dataTableBody: "Data table body",
+  dataTableHeader: "Data table header",
+  expandRows: "Expand rows",
+  fullText: "Full text",
+  fullTextAriaLabel: "Full text section",
+  hiddenColumns: "Hidden columns",
+  hiddenColumnsAriaLabel: "Hidden columns list",
+  hideColumn: "Hide column",
+  layoutSettings: "Layout settings",
+  layoutSettingsAriaLabel: "Layout settings section",
+  noHiddenColumns: "No Hidden columns",
+  pinRows: "Pin rows",
+  reset: "Reset columns",
+  resizeColumn: "Resize column",
+  rowDensity: "Row density",
+  rowDensityAriaLabel: "Row density section",
+  searchHiddenColumns: "Search...",
+  selectRow: "Select row",
+  settings: "Table settings",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Text previews",
+  textPreviewsAriaLabel: "Text previews section",
+  textVisibility: "Text visibility",
+  textVisibilityAriaLabel: "Text visibility section",
+  visibleColumns: "Visible columns",
+  visibleColumnsAria: "Visible columns list",
+  visibleColumnsList: "Visible columns"
+}, Ti = {
+  comfortable: "Komfortabel",
+  comfortableAriaLabel: "Komfortabler Bereich",
+  compact: "Kompakt",
+  compactAriaLabel: "Kompakter Bereich",
+  dataTable: "Datentabelle",
+  dataTableBody: "Datentabellenkörper",
+  dataTableHeader: "Datentabellenüberschrift",
+  expandRows: "Zeilen erweitern",
+  fullText: "Vollständiger Text",
+  fullTextAriaLabel: "Volltextbereich",
+  hiddenColumns: "Ausgeblendete Spalten",
+  hiddenColumnsAriaLabel: "Ausgeblendete Spaltenliste",
+  hideColumn: "Spalte ausblenden",
+  layoutSettings: "Layout-Einstellungen",
+  layoutSettingsAriaLabel: "Bereich Layout-Einstellungen",
+  noHiddenColumns: "Keine ausgeblendeten Spalten",
+  pinRows: "Zeilen fixieren",
+  reset: "Spalten zurücksetzen",
+  resizeColumn: "Spalte vergrößern",
+  rowDensity: "Zeilendichte",
+  rowDensityAriaLabel: "Abschnitt Zellendichte",
+  searchHiddenColumns: "Suche ...",
+  selectRow: "Zeile auswählen",
+  settings: "Tabellen-Einstellungen",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Textvorschau",
+  textPreviewsAriaLabel: "Abschnitt Textvorschau",
+  textVisibility: "Textsichtbarkeit",
+  textVisibilityAriaLabel: "Abschnitt Textsichtbarkeit",
+  visibleColumns: "Sichtbare Spalten",
+  visibleColumnsAria: "Sichtbare Spaltenliste",
+  visibleColumnsList: "Sichtbare Spalten"
+}, Bi = {
+  comfortable: "Cómoda",
+  comfortableAriaLabel: "Sección cómoda",
+  compact: "Compacta",
+  compactAriaLabel: "Sección compacta",
+  dataTable: "Tabla de datos",
+  dataTableBody: "Cuerpo de la tabla de datos",
+  dataTableHeader: "Encabezamiento de la tabla de datos",
+  expandRows: "Extender filas",
+  fullText: "Texto completo",
+  fullTextAriaLabel: "Sección de texto completo",
+  hiddenColumns: "Columnas ocultas",
+  hiddenColumnsAriaLabel: "Lista de columnas ocultas",
+  hideColumn: "Ocultar columna",
+  layoutSettings: "Configuraciones de formato",
+  layoutSettingsAriaLabel: "Sección de configuraciones de formato",
+  noHiddenColumns: "Sin columnas ocultas",
+  pinRows: "Fijar filas",
+  reset: "Restablecer columnas",
+  resizeColumn: "Ajustar tamaño de columna",
+  rowDensity: "Densidad de filas",
+  rowDensityAriaLabel: "Sección de densidad de filas",
+  searchHiddenColumns: "Buscar...",
+  selectRow: "Seleccionar fila",
+  settings: "Configuraciones de tablas",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Vistas preliminares de texto",
+  textPreviewsAriaLabel: "Sección de vistas preliminares de texto",
+  textVisibility: "Visibilidad de texto",
+  textVisibilityAriaLabel: "Sección de visibilidad de texto",
+  visibleColumns: "Columnas visibles",
+  visibleColumnsAria: "Lista de columnas visibles",
+  visibleColumnsList: "Columnas visibles"
+}, Ii = {
+  comfortable: "Confortable",
+  comfortableAriaLabel: "Section Confortable",
+  compact: "Compact",
+  compactAriaLabel: "Section Compact",
+  dataTable: "Tableau de données",
+  dataTableBody: "Corps du tableau de données",
+  dataTableHeader: "En-tête du tableau de données",
+  expandRows: "Agrandir les lignes",
+  fullText: "Texte complet",
+  fullTextAriaLabel: "Section Texte complet",
+  hiddenColumns: "Colonnes masquées",
+  hiddenColumnsAriaLabel: "Liste des colonnes masquées",
+  hideColumn: "Masquer la colonne",
+  layoutSettings: "Paramètres de disposition",
+  layoutSettingsAriaLabel: "Section Paramètres de disposition",
+  noHiddenColumns: "Pas de colonnes masquées",
+  pinRows: "Épingler les lignes",
+  reset: "Réinitialiser les colonnes",
+  resizeColumn: "Modifier la taille de la colonne",
+  rowDensity: "Densité des lignes",
+  rowDensityAriaLabel: "Section Densité des lignes",
+  searchHiddenColumns: "Rechercher...",
+  selectRow: "Sélectionner une ligne",
+  settings: "Paramètres du tableau",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Aperçu du texte",
+  textPreviewsAriaLabel: "Section Aperçu du texte",
+  textVisibility: "Visibilité du texte",
+  textVisibilityAriaLabel: "Section Visibilité du texte",
+  visibleColumns: "Colonnes visibles",
+  visibleColumnsAria: "Liste des colonnes visibles",
+  visibleColumnsList: "Colonnes visibles"
+}, Mi = {
+  comfortable: "Confortável",
+  comfortableAriaLabel: "Seção confortável",
+  compact: "Compacto",
+  compactAriaLabel: "Seção compacta",
+  dataTable: "Tabela de dados",
+  dataTableBody: "Corpo da tabela de dados",
+  dataTableHeader: "Cabeçalho da tabela de dados",
+  expandRows: "Expandir linhas",
+  fullText: "Texto completo",
+  fullTextAriaLabel: "Seção de texto completo",
+  hiddenColumns: "Colunas ocultas",
+  hiddenColumnsAriaLabel: "Lista de colunas ocultas",
+  hideColumn: "Ocultar coluna",
+  layoutSettings: "Configurações de layout",
+  layoutSettingsAriaLabel: "Seção de configurações de layout",
+  noHiddenColumns: "Sem colunas ocultas",
+  pinRows: "Fixar linhas",
+  reset: "Redefinir colunas",
+  resizeColumn: "Redimensionar colunas",
+  rowDensity: "Densidade da linha",
+  rowDensityAriaLabel: "Seção de densidade da linha",
+  searchHiddenColumns: "Buscar...",
+  selectRow: "Selecionar linha",
+  settings: "Configurações da tabela",
+  settingsTabsAriaLabel: "Settings tabs",
+  textPreviews: "Pré-visualizações de texto",
+  textPreviewsAriaLabel: "Seção de pré-visualizações de texto",
+  textVisibility: "Visibilidade do texto",
+  textVisibilityAriaLabel: "Seção de visibilidade do texto",
+  visibleColumns: "Colunas visíveis",
+  visibleColumnsAria: "Lista de colunas visíveis",
+  visibleColumnsList: "Colunas visíveis"
+}, fe = {
+  en: /* @__PURE__ */ Ie(Ri),
+  de: /* @__PURE__ */ Ie(Ti),
+  es: /* @__PURE__ */ Ie(Bi),
+  "fr-FR": /* @__PURE__ */ Ie(Ii),
+  "pt-BR": /* @__PURE__ */ Ie(Mi)
+}, kt = function({
+  ref: e,
+  children: l,
+  "aria-label": n,
+  ...r
+}) {
+  const i = K(null), o = ee(Le(i, e)), u = ue(fe), {
+    sortDescriptor: s,
+    onSortChange: c,
+    selectionMode: d,
+    onSelectionChange: a,
+    selectedKeys: f,
+    defaultSelectedKeys: p,
+    disallowEmptySelection: h,
+    disabledKeys: b
+  } = ye(), [C, y] = Te(r), g = n ?? u.format("dataTable"), m = s ? {
+    column: s.column,
+    direction: s.direction
+  } : void 0;
+  return /* @__PURE__ */ x(wi, { ...C, asChild: !0, children: /* @__PURE__ */ x(
+    li,
+    {
+      ref: o,
+      "aria-label": g,
+      sortDescriptor: m,
+      onSortChange: ($) => {
+        $ && c && c({
+          column: String($.column),
+          direction: $.direction
+        });
+      },
+      selectedKeys: f,
+      defaultSelectedKeys: p,
+      onSelectionChange: a,
+      selectionMode: d,
+      disallowEmptySelection: h,
+      disabledKeys: b,
+      disabledBehavior: "all",
+      ...y,
+      children: l
+    }
+  ) });
+};
+kt.displayName = "DataTable.Table";
+const Ne = ({
+  children: t,
+  ref: e,
+  column: l,
+  isInternalColumn: n,
+  width: r,
+  minWidth: i,
+  maxWidth: o,
+  ...u
+}) => {
+  const s = ue(fe), { sortDescriptor: c, isResizable: d } = ye(), a = c?.column === l?.id, f = l?.isResizable !== void 0 ? l?.isResizable : d, [p, h] = Te(u);
+  return /* @__PURE__ */ x(Si, { ...p, asChild: !0, children: /* @__PURE__ */ x(
+    di,
+    {
+      width: r,
+      minWidth: i,
+      maxWidth: o,
+      ref: e,
+      ...h,
+      children: (b) => {
+        const { allowsSorting: C } = b;
+        return n ? typeof t == "function" ? t(b) : t : /* @__PURE__ */ z(
+          xr,
+          {
+            tabIndex: f || C ? -1 : 0,
+            className: "nimbus-data-table__column-container",
+            children: [
+              /* @__PURE__ */ x(
+                rl,
+                {
+                  orientation: "vertical",
+                  className: "data-table-column-divider"
+                }
+              ),
+              typeof t == "function" ? t(b) : t,
+              C && /* @__PURE__ */ x(
+                Pi,
+                {
+                  "aria-hidden": "true",
+                  "data-sort-active": a,
+                  "data-sort-direction": a ? c?.direction : "none",
+                  children: /* @__PURE__ */ x(bn, {})
+                }
+              ),
+              f && /* @__PURE__ */ x(ci, { "aria-label": s.format("resizeColumn"), children: ({ isResizing: y, isFocused: g, isHovered: m }) => /* @__PURE__ */ x(
+                Ki,
+                {
+                  "data-resizing": y,
+                  "data-focused": g,
+                  "data-hovered": m
+                }
+              ) })
+            ]
+          }
+        );
+      }
+    }
+  ) });
+};
+Ne.displayName = "DataTable.Column";
+const Et = ({
+  ref: t,
+  "aria-label": e,
+  ...l
+}) => {
+  const n = ue(fe), { activeColumns: r, allowsSorting: i, maxHeight: o, showExpandColumn: u } = ye(), { selectionBehavior: s, selectionMode: c } = sn(), [d, a] = Te(l), f = e ?? n.format("dataTableHeader");
+  return /* @__PURE__ */ x(Di, { ...d, asChild: !0, children: /* @__PURE__ */ z(
+    oi,
+    {
+      ref: t,
+      "aria-label": f,
+      className: "data-table-header",
+      ...o && { "data-sticky": !0 },
+      columns: r,
+      ...a,
+      children: [
+        s === "toggle" && /* @__PURE__ */ x(
+          Ne,
+          {
+            id: "selection",
+            className: "selection-column-header",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            children: c === "multiple" && /* @__PURE__ */ x(sl, { slot: "selection" })
+          }
+        ),
+        u && /* @__PURE__ */ x(
+          Ne,
+          {
+            className: "expand-column-header",
+            maxWidth: s === "toggle" ? 24 : 72,
+            minWidth: s === "toggle" ? 24 : 72,
+            allowsSorting: !1,
+            "aria-label": n.format("expandRows"),
+            isInternalColumn: !0,
+            children: /* @__PURE__ */ x(Xt, { children: n.format("expandRows") })
+          }
+        ),
+        /* @__PURE__ */ x(He, { items: r, children: (p) => /* @__PURE__ */ z(
+          Ne,
+          {
+            allowsSorting: (
+              // use column.isSortable if defined, and fallback to allowsSorting if not
+              p.isSortable !== void 0 ? p.isSortable : i
+            ),
+            isRowHeader: !0,
+            width: p.width,
+            defaultWidth: p.defaultWidth,
+            minWidth: p.minWidth ?? 150,
+            maxWidth: p.maxWidth,
+            column: p,
+            children: [
+              /* @__PURE__ */ x("span", { "data-multiline-header": !0, children: p.header }),
+              p.headerIcon && /* @__PURE__ */ x(se, { as: "span", ml: "200", children: p.headerIcon })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ x(
+          Ne,
+          {
+            className: "pin-rows-column-header",
+            id: "pin-rows",
+            maxWidth: 72,
+            minWidth: 72,
+            allowsSorting: !1,
+            isInternalColumn: !0,
+            "aria-label": n.format("pinRows"),
+            children: /* @__PURE__ */ x(Xt, { children: n.format("pinRows") })
+          }
+        )
+      ]
+    }
+  ) });
+};
+Et.displayName = "DataTable.Header";
+const ze = ({
+  ref: t,
+  children: e,
+  isDisabled: l,
+  ...n
+}) => {
+  const [r, i] = Te(n);
+  return /* @__PURE__ */ x(Ei, { asChild: !0, ...r, children: /* @__PURE__ */ x(mi, { ref: t, ...i, children: (o) => /* @__PURE__ */ x(ol.Provider, { value: { isDisabled: l }, children: typeof e == "function" ? e(o) : e }) }) });
+};
+ze.displayName = "DataTable.Cell";
+function ht(t) {
+  return t.target?.closest(
+    'button, input, [role="button"], [role="checkbox"], [slot="selection"], [data-slot="selection"]'
+  );
+}
+function ll(t) {
+  ht(t) || t.stopPropagation();
+}
+const pn = ({
+  row: t,
+  ref: e,
+  ...l
+}) => {
+  const n = ue(fe), {
+    activeColumns: r,
+    search: i,
+    expanded: o,
+    toggleExpand: u,
+    nestedKey: s,
+    disabledKeys: c,
+    showExpandColumn: d,
+    showSelectionColumn: a,
+    isTruncated: f,
+    onRowClick: p,
+    onRowAction: h,
+    pinnedRows: b,
+    togglePin: C,
+    sortedRows: y
+  } = ye(), [g, m] = Te(l), $ = ((v) => c ? c === "all" || t.isDisabled ? !0 : c.has(v) : !1)(t.id), S = K(null), k = M(
+    (v) => {
+      if (!p) return;
+      const P = ht(v), W = window.getSelection()?.toString() !== void 0 && window.getSelection().toString().length > 0;
+      !P && !W && (S.current && window.clearTimeout(S.current), S.current = window.setTimeout(() => {
+        $ ? h && h(t, "click") : p(t), S.current = null;
+      }, 300));
+    },
+    [p, h, t, $]
+  ), B = M((v) => {
+    ht(v) || S.current && (window.clearTimeout(S.current), S.current = null);
+  }, []), R = K({
+    count: 0,
+    node: void 0
+  }), F = M(
+    (v) => {
+      R.current.count += 1, R.current.count === 1 && v && (R.current.node = v, v.addEventListener(
+        // Use pointerdown event in order to capture event before it bubbles to react-aria's onPress handler
+        "pointerdown",
+        ll,
+        {
+          capture: !0
+        }
+      ), v.addEventListener("mouseup", k, { capture: !0 }), v.addEventListener("dblclick", B, {
+        capture: !0
+      }));
+    },
+    [k, B]
+  );
+  he(() => {
+    const v = R.current;
+    return () => {
+      S.current && (window.clearTimeout(S.current), S.current = null), v.count >= 1 && v.node && (v.node.removeEventListener(
+        "pointerdown",
+        ll
+      ), v.node.removeEventListener("mouseup", k), v.node.removeEventListener("dblclick", B));
+    };
+  }, [k, B]);
+  const j = Le(e, F), { selectionBehavior: H } = sn(), U = s && t[s] && (Array.isArray(t[s]) ? t[s].length > 0 : !0), T = o.has(t.id), I = b.has(t.id), L = y.filter((v) => b.has(v.id)).map((v) => v.id), Y = I ? L.indexOf(t.id) : -1, re = Y === 0, pe = Y === L.length - 1, xe = L.length === 1 && I, ie = () => I ? xe ? "data-table-row-pinned-single" : re ? "data-table-row-pinned-first" : pe ? "data-table-row-pinned-last" : "" : "", oe = (v) => i && typeof v == "string" ? /* @__PURE__ */ x(yr, { query: i, ignoreCase: !0, matchAll: !0, children: v }) : v;
+  return /* @__PURE__ */ z(Me, { children: [
+    /* @__PURE__ */ x(tl, { asChild: !0, ...g, children: /* @__PURE__ */ z(
+      el,
+      {
+        isDisabled: $,
+        columns: r,
+        ref: j,
+        id: t.id,
+        "data-clickable": !!p && !$,
+        className: `data-table-row ${$ ? "data-table-row-disabled" : ""} ${I ? `data-table-row-pinned ${ie()}` : ""}`,
+        ...m,
+        dependencies: [T, i, f],
+        children: [
+          H === "toggle" && /* @__PURE__ */ x(
+            ze,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "selection",
+              isDisabled: $,
+              children: /* @__PURE__ */ x(
+                se,
+                {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  w: "100%",
+                  h: "100%",
+                  children: /* @__PURE__ */ x(
+                    sl,
+                    {
+                      name: "select-row",
+                      slot: "selection",
+                      "aria-label": n.format("selectRow")
+                    }
+                  )
+                }
+              )
+            }
+          ),
+          d && /* @__PURE__ */ x(
+            ze,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "expand",
+              isDisabled: $,
+              children: U ? (
+                // TODO:Button does not occupy the whole height
+                /* @__PURE__ */ x(
+                  il,
+                  {
+                    w: "100%",
+                    h: "100%",
+                    unstyled: !0,
+                    cursor: "pointer",
+                    focusVisibleRing: "inside",
+                    borderRadius: "0",
+                    "aria-label": T ? "Collapse" : "Expand",
+                    onPress: () => u(t.id),
+                    children: T ? /* @__PURE__ */ x(yn, {}) : /* @__PURE__ */ x(xn, {})
+                  }
+                )
+              ) : null
+            }
+          ),
+          /* @__PURE__ */ x(He, { items: r, children: (v) => {
+            const P = v.accessor(t);
+            return /* @__PURE__ */ x(ze, { isDisabled: $, children: /* @__PURE__ */ x(
+              se,
+              {
+                className: f ? "truncated-cell" : "",
+                "data-truncated": f ? "true" : "false",
+                display: "inline-block",
+                minW: "0",
+                maxW: "100%",
+                position: "relative",
+                overflow: "hidden",
+                cursor: $ ? "not-allowed" : void 0,
+                children: v.render ? v.render({
+                  value: oe(P),
+                  row: t,
+                  column: v
+                }) : oe(P)
+              }
+            ) }, v.id);
+          } }),
+          /* @__PURE__ */ x(
+            ze,
+            {
+              className: "data-table-sticky-cell",
+              "data-slot": "pin-row-cell",
+              isDisabled: $,
+              children: /* @__PURE__ */ x(
+                se,
+                {
+                  "data-slot": I ? "nimbus-table-cell-pin-button-pinned" : "nimbus-table-cell-pin-button",
+                  children: /* @__PURE__ */ z(qe.Root, { children: [
+                    /* @__PURE__ */ x(
+                      Fe,
+                      {
+                        size: "2xs",
+                        variant: "ghost",
+                        "aria-label": I ? "Unpin row" : "Pin row",
+                        colorPalette: "primary",
+                        isSelected: I,
+                        onChange: () => C(t.id),
+                        children: /* @__PURE__ */ x($n, {})
+                      },
+                      "pin-btn"
+                    ),
+                    /* @__PURE__ */ x(qe.Content, { placement: "top", children: I ? "Unpin row" : "Pin row" })
+                  ] })
+                }
+              )
+            }
+          )
+        ]
+      }
+    ) }),
+    d && /* @__PURE__ */ x(tl, { ...g, asChild: !0, children: /* @__PURE__ */ x(
+      el,
+      {
+        "data-nested-row-expanded": T ? "true" : "false",
+        dependencies: [T],
+        children: /* @__PURE__ */ x(
+          ze,
+          {
+            isDisabled: $,
+            colSpan: r.length + (d ? 1 : 0) + (a ? 1 : 0) + 1,
+            "data-nested-cell": !0,
+            children: T ? s && Array.isArray(t[s]) ? `${t[s].length} nested items` : s && t[s] : null
+          }
+        )
+      }
+    ) })
+  ] });
+};
+pn.displayName = "DataTable.Row";
+const Fi = () => /* @__PURE__ */ x(se, { w: "100%", p: "200", children: "No Data" }), zt = ({
+  ref: t,
+  "aria-label": e,
+  ...l
+}) => {
+  const n = ue(fe), { sortedRows: r, activeColumns: i, renderEmptyState: o } = ye(), [u, s] = Te(l), c = e ?? n.format("dataTableBody");
+  return /* @__PURE__ */ x(ki, { asChild: !0, ...u, children: /* @__PURE__ */ x(
+    pi,
+    {
+      ref: t,
+      "aria-label": c,
+      items: r,
+      dependencies: [i],
+      renderEmptyState: o ?? Fi,
+      ...s,
+      children: (d) => /* @__PURE__ */ x(pn, { row: d }, d.id)
+    }
+  ) });
+};
+zt.displayName = "DataTable.Body";
+const Pt = function({
+  ref: e,
+  children: l,
+  ...n
+}) {
+  const r = K(null), i = ee(Le(r, e));
+  return /* @__PURE__ */ x(zi, { ref: i, ...n, children: l });
+};
+Pt.displayName = "DataTable.Footer";
+function Ni(t) {
+  return "onRemoveItem" in t && typeof t.onRemoveItem == "function";
+}
+const Vi = ({
+  hiddenItems: t,
+  visibleItems: e,
+  handleVisibleColumnsUpdate: l,
+  handleResetColumns: n
+}) => {
+  const [r, i] = Z(""), o = ue(fe), u = A(() => t.filter(
+    (a) => a.label?.toString().toLowerCase().includes(r.toLowerCase())
+  ), [t, r]), s = (a) => {
+    i(a);
+  }, c = M(
+    (a) => {
+      const f = new Set(t.map((y) => y.id)), p = new Set(
+        a.map((y) => y.id)
+      ), h = t.filter(
+        (y) => !p.has(y.id)
+      ), b = a.filter(
+        (y) => !f.has(y.id)
+      );
+      let C = [...e];
+      if (h.length > 0 && (C = [...C, ...h]), b.length > 0) {
+        const y = new Set(b.map((g) => g.id));
+        C = C.filter(
+          (g) => !y.has(g.id)
+        );
+      }
+      l(C);
+    },
+    [t, e, l]
+  ), d = M(
+    (a) => {
+      l(a);
+    },
+    [l]
+  );
+  return !t || !e ? null : /* @__PURE__ */ z(Ye, { mt: "800", children: [
+    /* @__PURE__ */ z(Ee, { gap: "400", width: "100%", columns: 2, children: [
+      /* @__PURE__ */ z(se, { children: [
+        /* @__PURE__ */ z(Ye, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(Cn, {}),
+          /* @__PURE__ */ x(Ve, { fontWeight: "700", fontSize: "sm", w: "full", children: o.format("hiddenColumns") })
+        ] }),
+        /* @__PURE__ */ z(
+          Ye,
+          {
+            colorPalette: "primary",
+            border: "{sizes.25} solid",
+            borderColor: "colorPalette.3",
+            borderRadius: "200",
+            gap: "200",
+            p: "300",
+            h: "lg",
+            children: [
+              /* @__PURE__ */ x(
+                An,
+                {
+                  w: "full",
+                  size: "sm",
+                  variant: "ghost",
+                  placeholder: o.format("searchHiddenColumns"),
+                  "aria-label": o.format("searchHiddenColumns"),
+                  onChange: s,
+                  value: r,
+                  "data-testid": "search-hidden-columns"
+                }
+              ),
+              /* @__PURE__ */ x(
+                rl,
+                {
+                  colorPalette: "primary",
+                  border: "{sizes.25} solid",
+                  borderColor: "colorPalette.3"
+                }
+              ),
+              /* @__PURE__ */ x(
+                Ue.Root,
+                {
+                  border: "none",
+                  borderColor: "none",
+                  h: "full",
+                  w: "full",
+                  overflowY: "auto",
+                  items: u,
+                  onUpdateItems: c,
+                  "aria-label": o.format("hiddenColumnsAriaLabel"),
+                  "data-testid": "hidden-columns-list",
+                  renderEmptyState: /* @__PURE__ */ x(Ve, { fontSize: "sm", color: "gray.9", children: o.format("noHiddenColumns") }),
+                  children: (a) => /* @__PURE__ */ x(
+                    Ue.Item,
+                    {
+                      py: "100",
+                      id: a.id,
+                      "aria-label": a.label?.toString() ?? a.id,
+                      children: a.label
+                    },
+                    a.id
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ z(se, { children: [
+        /* @__PURE__ */ z(Ye, { direction: "row", alignItems: "center", mb: "200", children: [
+          /* @__PURE__ */ x(vn, {}),
+          /* @__PURE__ */ x(Ve, { fontWeight: "700", fontSize: "sm", children: o.format("visibleColumnsList") })
+        ] }),
+        /* @__PURE__ */ x(
+          Ue.Root,
+          {
+            removableItems: !0,
+            p: "300",
+            h: "lg",
+            overflowY: "auto",
+            items: e,
+            onUpdateItems: d,
+            "aria-label": o.format("visibleColumnsAria"),
+            "data-testid": "visible-columns-list",
+            children: (a) => /* @__PURE__ */ x(
+              Ue.Item,
+              {
+                py: "100",
+                id: a.id,
+                onRemoveItem: Ni(a) ? a.onRemoveItem : void 0,
+                "aria-label": a.label?.toString() ?? a.id,
+                children: a.label
+              },
+              a.id
+            )
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ x(se, { children: /* @__PURE__ */ z(
+      Tn,
+      {
+        variant: "ghost",
+        colorPalette: "primary",
+        size: "xs",
+        onPress: n,
+        "aria-label": o.format("reset"),
+        children: [
+          /* @__PURE__ */ x(wn, {}),
+          o.format("reset")
+        ]
+      }
+    ) })
+  ] });
+}, nl = {
+  TOGGLE_TEXT_VISIBILITY: "toggleTextVisibility",
+  TOGGLE_ROW_DENSITY: "toggleRowDensity"
+}, Li = ({
+  onSettingsChange: t
+}) => {
+  const e = ue(fe), l = ye(), n = l.isTruncated ?? !1, r = l.density === "condensed" ? "compact" : "comfortable", i = (u) => {
+    Array.from(u)[0] && t?.(nl.TOGGLE_TEXT_VISIBILITY);
+  }, o = (u) => {
+    Array.from(u)[0] && t?.(nl.TOGGLE_ROW_DENSITY);
+  };
+  return /* @__PURE__ */ z(
+    Ee,
+    {
+      templateColumns: "repeat(4, 1fr)",
+      columnGap: "400",
+      rowGap: "600",
+      mt: "800",
+      alignItems: "center",
+      children: [
+        /* @__PURE__ */ x(Ee.Item, { colSpan: 1, children: /* @__PURE__ */ x(Ve, { fontWeight: "500", children: e.format("textVisibility") }) }),
+        /* @__PURE__ */ x(Ee.Item, { colSpan: 3, children: /* @__PURE__ */ x(Lt, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ z(
+          Ht.Root,
+          {
+            w: "full",
+            selectedKeys: n ? ["preview"] : ["full"],
+            onSelectionChange: i,
+            "aria-label": e.format("textVisibilityAriaLabel"),
+            children: [
+              /* @__PURE__ */ z(
+                Fe,
+                {
+                  id: "full",
+                  size: "xs",
+                  "aria-label": e.format("fullText"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(Dn, {}),
+                    e.format("fullText")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ z(
+                Fe,
+                {
+                  id: "preview",
+                  size: "xs",
+                  "aria-label": e.format("textPreviews"),
+                  variant: "ghost",
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(Sn, {}),
+                    e.format("textPreviews")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) }),
+        /* @__PURE__ */ x(Ee.Item, { colSpan: 1, children: /* @__PURE__ */ x(Ve, { fontWeight: "500", children: e.format("rowDensity") }) }),
+        /* @__PURE__ */ x(Ee.Item, { colSpan: 3, children: /* @__PURE__ */ x(Lt, { orientation: "horizontal", variant: "outline", size: "xs", w: "full", children: /* @__PURE__ */ z(
+          Ht.Root,
+          {
+            w: "full",
+            colorPalette: "primary",
+            selectedKeys: [r],
+            onSelectionChange: o,
+            "aria-label": e.format("rowDensityAriaLabel"),
+            children: [
+              /* @__PURE__ */ z(
+                Fe,
+                {
+                  id: "comfortable",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("comfortable"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(kn, {}),
+                    e.format("comfortable")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ z(
+                Fe,
+                {
+                  id: "compact",
+                  size: "xs",
+                  variant: "ghost",
+                  "aria-label": e.format("compact"),
+                  px: "300",
+                  flex: "1",
+                  children: [
+                    /* @__PURE__ */ x(En, {}),
+                    e.format("compact")
+                  ]
+                }
+              )
+            ]
+          }
+        ) }) })
+      ]
+    }
+  );
+}, mn = () => {
+  const [t, e] = Z(!1), l = ye(), n = ue(fe), {
+    columns: r,
+    visibleColumns: i,
+    onColumnsChange: o,
+    onSettingsChange: u
+    // customSettings,
+  } = l, s = r.filter(
+    (g) => !i?.includes(g.id)
+  ), { customSettings: c } = Ai(), d = K(r);
+  he(() => {
+    d.current = r;
+  }, [r]);
+  const a = K(r), f = K(i), p = K(i || []), h = A(() => (g) => {
+    const m = g.map((k) => k.id);
+    if (!(m.length !== p.current.length || m.some(
+      (k, B) => k !== p.current[B]
+    )))
+      return;
+    const $ = new Map(d.current.map((k) => [k.id, k])), S = g.map((k) => $.get(k.id)).filter(
+      (k) => k !== void 0
+    );
+    p.current = m, o && o(S);
+  }, []), b = A(() => r.filter((g) => !i?.includes(g.id)).map((g) => ({
+    key: g.id,
+    id: g.id,
+    label: g.header
+  })), [i, r]), C = A(() => {
+    if (!i || i.length === 0)
+      return [];
+    const g = new Map(r.map((m) => [m.id, m]));
+    return i.map((m) => {
+      const w = g.get(m);
+      return w ? {
+        key: w.id,
+        id: w.id,
+        label: w.header
+      } : null;
+    }).filter((m) => m !== null);
+  }, [r, i]), y = M(() => {
+    if (o) {
+      const g = f.current;
+      if (g && g.length > 0) {
+        const m = new Map(
+          a.current.map(($) => [$.id, $])
+        ), w = g.map(($) => m.get($)).filter(
+          ($) => $ !== void 0
+        );
+        p.current = g, o(w);
+      } else
+        p.current = a.current.map(
+          (m) => m.id
+        ), o(a.current);
+    }
+  }, [o]);
+  return !i || !s ? null : /* @__PURE__ */ z(Me, { children: [
+    /* @__PURE__ */ z(qe.Root, { children: [
+      /* @__PURE__ */ x(qe.Content, { placement: "top", children: n.format("settings") }),
+      /* @__PURE__ */ x(
+        il,
+        {
+          variant: "ghost",
+          colorPalette: "primary",
+          size: "xs",
+          "aria-label": n.format("settings"),
+          onPress: () => e(!0),
+          children: /* @__PURE__ */ x(zn, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ x(
+      we.Root,
+      {
+        isOpen: t,
+        onOpenChange: e,
+        placement: "right",
+        "data-testid": "data-table-manager-drawer",
+        children: /* @__PURE__ */ z(
+          we.Content,
+          {
+            width: "2xl",
+            "data-testid": "data-table-manager-drawer",
+            "aria-label": n.format("settings"),
+            children: [
+              /* @__PURE__ */ z(we.Header, { children: [
+                /* @__PURE__ */ x(we.Title, { children: n.format("settings") }),
+                /* @__PURE__ */ x(we.CloseTrigger, {})
+              ] }),
+              /* @__PURE__ */ x(we.Body, { children: /* @__PURE__ */ x(
+                Bn.Root,
+                {
+                  tabListAriaLabel: n.format("settingsTabsAriaLabel"),
+                  tabs: [
+                    {
+                      id: "visible-columns",
+                      tabLabel: /* @__PURE__ */ z(Me, { children: [
+                        /* @__PURE__ */ x(Pn, {}),
+                        n.format("visibleColumns")
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(
+                        Vi,
+                        {
+                          hiddenItems: b,
+                          visibleItems: C,
+                          handleVisibleColumnsUpdate: h,
+                          handleResetColumns: y
+                        }
+                      )
+                    },
+                    {
+                      id: "layout-settings",
+                      tabLabel: /* @__PURE__ */ z(Me, { children: [
+                        /* @__PURE__ */ x(Kn, {}),
+                        n.format("layoutSettings")
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(Li, { onSettingsChange: u })
+                    },
+                    c ? {
+                      id: "custom-settings",
+                      tabLabel: /* @__PURE__ */ z(Me, { children: [
+                        c?.icon ?? null,
+                        c?.label
+                      ] }),
+                      panelContent: /* @__PURE__ */ x(se, { mt: "800", children: c.panel })
+                    } : null
+                    // Filter out null values when no custom settings are provided
+                  ].filter((g) => g !== null)
+                }
+              ) })
+            ]
+          }
+        )
+      }
+    )
+  ] });
+};
+mn.displayName = "DataTable.Manager";
+const Hi = function({
+  ref: e,
+  footer: l,
+  ...n
+}) {
+  const r = ue(fe), i = K(null), o = ee(Le(i, e));
+  return /* @__PURE__ */ z(St, { ref: o, ...n, children: [
+    /* @__PURE__ */ z(kt, { "aria-label": r.format("dataTable"), children: [
+      /* @__PURE__ */ x(Et, { "aria-label": r.format("dataTableHeader") }),
+      /* @__PURE__ */ x(zt, { "aria-label": r.format("dataTableBody") })
+    ] }),
+    l && /* @__PURE__ */ x(Pt, { children: l })
+  ] });
+}, ea = /* @__PURE__ */ Object.assign(Hi, {
+  /**
+   * # DataTable.Root
+   *
+   * The root container that provides context and state management for the entire data table.
+   * Handles data processing, sorting, filtering, selection, and expansion state.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows} allowsSorting>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Root: St,
+  /**
+   * # DataTable.Table
+   *
+   * The main table element that wraps the header and body components.
+   * Provides the semantic HTML table structure with React Aria table behavior.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Table: kt,
+  /**
+   * # DataTable.Header
+   *
+   * The table header section that renders column headers with sorting capabilities.
+   * Automatically generates columns based on the configuration provided to Root.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Header: Et,
+  /**
+   * # DataTable.Body
+   *
+   * The table body section that renders all data rows with selection and expansion capabilities.
+   * Handles empty states and provides accessibility features for row navigation.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   * </DataTable.Root>
+   * ```
+   */
+  Body: zt,
+  /**
+   * # DataTable.Footer
+   *
+   * Optional footer section for displaying summary information, pagination, or actions.
+   * Positioned below the table with proper styling integration.
+   *
+   * @example
+   * ```tsx
+   * <DataTable.Root columns={columns} rows={rows}>
+   *   <DataTable.Table>
+   *     <DataTable.Header />
+   *     <DataTable.Body />
+   *   </DataTable.Table>
+   *   <DataTable.Footer>
+   *     <Pagination />
+   *   </DataTable.Footer>
+   * </DataTable.Root>
+   * ```
+   */
+  Footer: Pt,
+  /**
+   * # 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: mn,
+  /**
+   * # DataTable.Context
+   *
+   * React context that provides shared state and configuration to all table components.
+   * Used internally for component coordination - not typically used directly.
+   *
+   * @example
+   * ```tsx
+   * const context = useContext(DataTable.Context);
+   * ```
+   */
+  Context: it,
+  /**
+   * # DataTable.useDataTableContext
+   *
+   * Hook that provides access to the DataTable context with proper error handling.
+   * Throws an error if used outside of a DataTable.Root provider.
+   *
+   * @example
+   * ```tsx
+   * const { columns, rows, sortDescriptor } = DataTable.useDataTableContext();
+   * ```
+   */
+  useDataTableContext: ye
+});
+export {
+  ea as D,
+  nl as U,
+  zt as a,
+  Pt as b,
+  Et as c,
+  mn as d,
+  St as e,
+  kt as f
+};
+//# sourceMappingURL=data-table-D3gTUqrT.es.js.map