@affino/datagrid-vue-app 0.1.2 → 0.1.3

package/dist/chunks/useDataGridAppRowModel-Di-Zatjs.js

@@ -0,0 +1,2761 @@
+import { defineComponent as Fn, h as k, computed as m, unref as c, ref as W, nextTick as Dn, onBeforeUnmount as En, watch as K, defineAsyncComponent as yt, shallowRef as _n } from "vue";
+import { resolveDataGridCellClickAction as Gn, toggleDataGridCellValue as Pn, buildDataGridCellRenderModel as Ln, useDataGridContextMenu as Wn, cloneDataGridFilterSnapshot as Kn, createClientRowModel as un } from "@affino/datagrid-vue";
+import { useDataGridAppIntentHistory as Nn, createDataGridAppRowHeightMetrics as $n, useDataGridAppViewport as Un, useDataGridAppRowSizing as qn, useDataGridAppCellSelection as Xn, useDataGridAppRowPresentation as Yn, useDataGridAppClipboard as Jn, useDataGridAppActiveCellViewport as Zn, useDataGridAppInlineEditing as Qn, useDataGridAppInteractionController as el, useDataGridAppHeaderResize as tl, useDataGridAppRuntimeSync as nl, useDataGridAppViewportLifecycle as ll, useDataGridAppColumnLayoutPanel as ol, useDataGridAppAdvancedFilterBuilder as rl } from "@affino/datagrid-vue/app";
+import { useDataGridViewportContextMenuRouter as il, useDataGridContextMenuAnchor as al, useDataGridContextMenuActionRouter as sl } from "@affino/datagrid-vue/advanced";
+import { c as ul, _ as cl } from "./DataGridTableStage.vue_vue_type_script_setup_true_lang-BJJoBCsA.js";
+const dl = Fn({
+  name: "DataGridModuleHost",
+  props: {
+    modules: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(e) {
+    return () => e.modules.length === 0 ? null : k("div", { class: "datagrid-app-toolbar" }, [
+      k("div", { class: "datagrid-app-toolbar__group" }, e.modules.map((o) => k(o.component, {
+        key: o.key,
+        ...o.props ?? {}
+      })))
+    ]);
+  }
+}), Z = ["sort", "group", "pin", "filter"], kn = [
+  "sortAsc",
+  "sortDesc",
+  "clearSort",
+  "toggleGroup",
+  "pinMenu",
+  "pinLeft",
+  "pinRight",
+  "unpin",
+  "clearFilter",
+  "addCurrentSelectionToFilter",
+  "selectAllValues",
+  "clearAllValues",
+  "applyFilter",
+  "cancelFilter"
+], cn = 120;
+function hn(e) {
+  const o = new Set(Z), r = Array.isArray(e) ? e : Z, l = [];
+  for (const s of r)
+    !o.has(s) || l.includes(s) || l.push(s);
+  return l.length > 0 ? l : [...Z];
+}
+function fn(e) {
+  if (!Array.isArray(e))
+    return [];
+  const o = new Set(Z), r = [];
+  for (const l of e)
+    !o.has(l) || r.includes(l) || r.push(l);
+  return r;
+}
+function Hn(e) {
+  if (!e)
+    return Object.freeze({});
+  const o = Object.entries(e).filter(([r, l]) => Z.includes(r) && typeof l == "string").map(([r, l]) => [r, l.trim()]).filter(([, r]) => r.length > 0);
+  return Object.freeze(Object.fromEntries(o));
+}
+function Vn(e) {
+  if (!e)
+    return Object.freeze({});
+  const o = Object.entries(e).filter(([r, l]) => Z.includes(r) && typeof l == "string").map(([r, l]) => [r, l.trim()]).filter(([, r]) => r.length > 0);
+  return Object.freeze(Object.fromEntries(o));
+}
+function zn(e) {
+  if (!e)
+    return Object.freeze({});
+  const o = Object.entries(e).filter(([r, l]) => kn.includes(r) && !!l).map(([r, l]) => {
+    const s = l, i = {
+      ...s.hidden === !0 ? { hidden: !0 } : {},
+      ...s.disabled === !0 ? { disabled: !0 } : {},
+      ...typeof s.disabledReason == "string" && s.disabledReason.trim().length > 0 ? { disabledReason: s.disabledReason.trim() } : {},
+      ...typeof s.label == "string" && s.label.trim().length > 0 ? { label: s.label.trim() } : {}
+    };
+    return [r, Object.freeze(i)];
+  }).filter(([, r]) => Object.keys(r).length > 0);
+  return Object.freeze(Object.fromEntries(o));
+}
+function ml(e) {
+  if (!e)
+    return {};
+  const o = Object.entries(e).filter(([r]) => r.trim().length > 0).map(([r, l]) => {
+    const s = l?.items ? hn(l.items) : void 0, i = fn(l?.hide), w = fn(l?.disabled), C = Vn(l?.disabledReasons), b = Hn(l?.labels), A = zn(l?.actions);
+    return [
+      r,
+      {
+        ...s ? { items: s } : {},
+        ...i.length > 0 ? { hide: i } : {},
+        ...w.length > 0 ? { disabled: w } : {},
+        ...Object.keys(C).length > 0 ? { disabledReasons: C } : {},
+        ...Object.keys(b).length > 0 ? { labels: b } : {},
+        ...Object.keys(A).length > 0 ? { actions: A } : {}
+      }
+    ];
+  });
+  return Object.fromEntries(o);
+}
+function ho(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    maxFilterValues: cn,
+    items: [...Z],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    columns: {}
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    maxFilterValues: Number.isFinite(e.maxFilterValues) ? Math.max(20, Math.trunc(e.maxFilterValues)) : cn,
+    items: hn(e.items),
+    disabled: fn(e.disabled),
+    disabledReasons: Vn(e.disabledReasons),
+    labels: Hn(e.labels),
+    actions: zn(e.actions),
+    columns: ml(e.columns)
+  } : {
+    enabled: !1,
+    maxFilterValues: cn,
+    items: [...Z],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    columns: {}
+  };
+}
+function Tn(e, o) {
+  const r = e.columns[o], l = r?.items ? hn(r.items) : e.items, s = new Set(r?.hide ?? []), i = l.filter((w) => !s.has(w));
+  return i.length > 0 ? i : [];
+}
+function wl(e, o) {
+  const r = Tn(e, o), l = new Set(e.columns[o]?.disabled ?? []), s = new Set(e.disabled);
+  return r.filter((i) => s.has(i) || l.has(i));
+}
+function fl(e, o) {
+  return Object.freeze({
+    ...e.labels,
+    ...e.columns[o]?.labels ?? {}
+  });
+}
+function Cl(e, o) {
+  return Object.freeze({
+    ...e.disabledReasons,
+    ...e.columns[o]?.disabledReasons ?? {}
+  });
+}
+function gl(e, o) {
+  const r = e.columns[o]?.actions ?? {}, l = kn.map((s) => {
+    const i = {
+      ...e.actions[s] ?? {},
+      ...r[s] ?? {}
+    };
+    return [s, Object.freeze(i)];
+  }).filter(([, s]) => Object.keys(s).length > 0);
+  return Object.freeze(Object.fromEntries(l));
+}
+const _ = ["clipboard", "edit"], Rn = ["cut", "copy", "paste", "clear"], ve = ["insert", "clipboard", "selection"], jn = [
+  "insertAbove",
+  "insertBelow",
+  "cut",
+  "copy",
+  "paste",
+  "deleteSelected"
+];
+function St(e, o) {
+  const r = new Set(o), l = Array.isArray(e) ? e : o, s = [];
+  for (const i of l)
+    !r.has(i) || s.includes(i) || s.push(i);
+  return s.length > 0 ? s : [...o];
+}
+function Rt(e, o) {
+  if (!Array.isArray(e))
+    return [];
+  const r = new Set(o), l = [];
+  for (const s of e)
+    !r.has(s) || l.includes(s) || l.push(s);
+  return l;
+}
+function be(e, o) {
+  if (!e)
+    return Object.freeze({});
+  const r = Object.entries(e).filter((l) => o.includes(l[0]) && typeof l[1] == "string").map(([l, s]) => [l, s.trim()]).filter(([, l]) => l.length > 0);
+  return Object.freeze(Object.fromEntries(r));
+}
+function yn(e, o) {
+  if (!e)
+    return Object.freeze({});
+  const r = Object.entries(e).filter(([l, s]) => o.includes(l) && !!s).map(([l, s]) => {
+    const i = s, w = {
+      ...i.hidden === !0 ? { hidden: !0 } : {},
+      ...i.disabled === !0 ? { disabled: !0 } : {},
+      ...typeof i.disabledReason == "string" && i.disabledReason.trim().length > 0 ? { disabledReason: i.disabledReason.trim() } : {},
+      ...typeof i.label == "string" && i.label.trim().length > 0 ? { label: i.label.trim() } : {}
+    };
+    return [l, Object.freeze(w)];
+  }).filter(([, l]) => Object.keys(l).length > 0);
+  return Object.freeze(Object.fromEntries(r));
+}
+function vl(e) {
+  if (!e)
+    return {};
+  const o = Object.entries(e).filter(([r]) => r.trim().length > 0).map(([r, l]) => {
+    const s = l?.items ? St(l.items, _) : void 0, i = Rt(l?.hide, _), w = Rt(l?.disabled, _), C = be(l?.disabledReasons, _), b = be(l?.labels, _), A = yn(l?.actions, Rn);
+    return [
+      r,
+      {
+        ...s ? { items: s } : {},
+        ...i.length > 0 ? { hide: i } : {},
+        ...w.length > 0 ? { disabled: w } : {},
+        ...Object.keys(C).length > 0 ? { disabledReasons: C } : {},
+        ...Object.keys(b).length > 0 ? { labels: b } : {},
+        ...Object.keys(A).length > 0 ? { actions: A } : {}
+      }
+    ];
+  });
+  return Object.freeze(Object.fromEntries(o));
+}
+function Ro(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    items: [..._],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    columns: {}
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    items: St(e.items, _),
+    disabled: Rt(e.disabled, _),
+    disabledReasons: be(e.disabledReasons, _),
+    labels: be(e.labels, _),
+    actions: yn(e.actions, Rn),
+    columns: vl(e.columns)
+  } : {
+    enabled: !1,
+    items: [..._],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    columns: {}
+  };
+}
+function ht(e, o) {
+  const r = e.columns[o], l = r?.items ? St(r.items, _) : e.items, s = new Set(r?.hide ?? []), i = l.filter((w) => !s.has(w));
+  return i.length > 0 ? i : [];
+}
+function bl(e, o) {
+  const r = ht(e, o), l = new Set(e.columns[o]?.disabled ?? []), s = new Set(e.disabled);
+  return r.filter((i) => s.has(i) || l.has(i));
+}
+function hl(e, o) {
+  return Object.freeze({
+    ...e.disabledReasons,
+    ...e.columns[o]?.disabledReasons ?? {}
+  });
+}
+function Rl(e, o) {
+  const r = e.columns[o]?.actions ?? {}, l = Rn.map((s) => {
+    const i = {
+      ...e.actions[s] ?? {},
+      ...r[s] ?? {}
+    };
+    return [s, Object.freeze(i)];
+  }).filter(([, s]) => Object.keys(s).length > 0);
+  return Object.freeze(Object.fromEntries(l));
+}
+function yo(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    items: [...ve],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({})
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    items: St(e.items, ve),
+    disabled: Rt(e.disabled, ve),
+    disabledReasons: be(e.disabledReasons, ve),
+    labels: be(e.labels, ve),
+    actions: yn(e.actions, jn)
+  } : {
+    enabled: !1,
+    items: [...ve],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({})
+  };
+}
+function yl(e) {
+  return e.items;
+}
+function Sl(e) {
+  return e.disabled;
+}
+function pl(e) {
+  return e.disabledReasons;
+}
+function Ml(e) {
+  const o = jn.map((r) => [r, Object.freeze({ ...e.actions[r] ?? {} })]).filter(([, r]) => Object.keys(r).length > 0);
+  return Object.freeze(Object.fromEntries(o));
+}
+function Sn(e) {
+  return (o) => {
+    e.value = o instanceof HTMLElement ? o : null;
+  };
+}
+function Il(e) {
+  const o = Sn(e.headerViewportRef), r = Sn(e.bodyViewportRef), l = (f) => {
+    e.editingCellValueRef.value = f;
+  }, s = m(() => ({
+    gridContentStyle: c(e.gridContentStyle),
+    mainTrackStyle: c(e.mainTrackStyle),
+    indexColumnStyle: c(e.indexColumnStyle),
+    columnStyle: c(e.columnStyle)
+  })), i = m(() => ({
+    topSpacerHeight: c(e.topSpacerHeight),
+    bottomSpacerHeight: c(e.bottomSpacerHeight),
+    viewportRowStart: c(e.viewportRowStart),
+    columnWindowStart: c(e.columnWindowStart),
+    leftColumnSpacerWidth: c(e.leftColumnSpacerWidth),
+    rightColumnSpacerWidth: c(e.rightColumnSpacerWidth),
+    headerViewportRef: o,
+    bodyViewportRef: r,
+    handleHeaderWheel: c(e.handleHeaderWheel),
+    handleHeaderScroll: c(e.handleHeaderScroll),
+    handleViewportScroll: c(e.handleViewportScroll),
+    handleViewportKeydown: c(e.handleViewportKeydown)
+  })), w = m(() => ({
+    visibleColumns: c(e.visibleColumns),
+    renderedColumns: c(e.renderedColumns),
+    columnFilterTextByKey: c(e.columnFilterTextByKey),
+    toggleSortForColumn: c(e.toggleSortForColumn),
+    sortIndicator: c(e.sortIndicator),
+    setColumnFilterText: c(e.setColumnFilterText),
+    columnMenuEnabled: c(e.columnMenuEnabled),
+    columnMenuValueFilterEnabled: c(e.columnMenuValueFilterEnabled),
+    columnMenuValueFilterRowLimit: c(e.columnMenuValueFilterRowLimit),
+    columnMenuMaxFilterValues: c(e.columnMenuMaxFilterValues),
+    resolveColumnMenuItems: c(e.resolveColumnMenuItems),
+    resolveColumnMenuDisabledItems: c(e.resolveColumnMenuDisabledItems),
+    resolveColumnMenuDisabledReasons: c(e.resolveColumnMenuDisabledReasons),
+    resolveColumnMenuLabels: c(e.resolveColumnMenuLabels),
+    resolveColumnMenuActionOptions: c(e.resolveColumnMenuActionOptions),
+    isColumnFilterActive: c(e.isColumnFilterActive),
+    isColumnGrouped: c(e.isColumnGrouped),
+    resolveColumnGroupOrder: c(e.resolveColumnGroupOrder),
+    resolveColumnMenuSortDirection: c(e.resolveColumnMenuSortDirection),
+    resolveColumnMenuSelectedTokens: c(e.resolveColumnMenuSelectedTokens),
+    applyColumnMenuSort: c(e.applyColumnMenuSort),
+    applyColumnMenuPin: c(e.applyColumnMenuPin),
+    applyColumnMenuGroupBy: c(e.applyColumnMenuGroupBy),
+    applyColumnMenuFilter: c(e.applyColumnMenuFilter),
+    clearColumnMenuFilter: c(e.clearColumnMenuFilter),
+    startResize: c(e.startResize),
+    handleResizeDoubleClick: c(e.handleResizeDoubleClick)
+  })), C = m(() => ({
+    displayRows: c(e.displayRows),
+    pinnedBottomRows: c(e.pinnedBottomRows),
+    sourceRows: c(e.sourceRows),
+    showRowIndex: c(e.showRowIndex),
+    rowHover: c(e.rowHover),
+    stripedRows: c(e.stripedRows),
+    rowClass: c(e.rowClass),
+    isRowAutosizeProbe: c(e.isRowAutosizeProbe),
+    rowStyle: c(e.rowStyle),
+    isRowInPendingClipboardCut: c(e.isRowInPendingClipboardCut),
+    isRowFocused: c(e.isRowFocused),
+    isRowCheckboxSelected: c(e.isRowCheckboxSelected),
+    allVisibleRowsSelected: c(e.allVisibleRowsSelected),
+    someVisibleRowsSelected: c(e.someVisibleRowsSelected),
+    handleRowClick: c(e.handleRowClick),
+    handleRowIndexClick: c(e.handleRowIndexClick),
+    handleRowIndexKeydown: c(e.handleRowIndexKeydown),
+    handleToggleAllVisibleRows: c(e.handleToggleAllVisibleRows),
+    toggleGroupRow: c(e.toggleGroupRow),
+    rowIndexLabel: c(e.rowIndexLabel),
+    startRowResize: c(e.startRowResize),
+    autosizeRow: c(e.autosizeRow)
+  })), b = m(() => ({
+    selectionRange: c(e.selectionRange),
+    selectionAnchorCell: c(e.selectionAnchorCell),
+    fillPreviewRange: c(e.fillPreviewRange),
+    rangeMovePreviewRange: c(e.rangeMovePreviewRange),
+    isFillDragging: c(e.isFillDragging),
+    isRangeMoving: c(e.isRangeMoving),
+    fillActionAnchorCell: c(e.fillActionAnchorCell),
+    fillActionBehavior: c(e.fillActionBehavior),
+    applyFillActionBehavior: c(e.applyFillActionBehavior),
+    isFillHandleCell: c(e.isFillHandleCell),
+    startFillHandleDrag: c(e.startFillHandleDrag),
+    startFillHandleDoubleClick: c(e.startFillHandleDoubleClick)
+  })), A = m(() => ({
+    editingCellValue: e.editingCellValueRef.value,
+    editingCellInitialFilter: c(e.editingCellInitialFilter),
+    editingCellOpenOnMount: c(e.editingCellOpenOnMount),
+    isEditingCell: c(e.isEditingCell),
+    startInlineEdit: c(e.startInlineEdit),
+    updateEditingCellValue: l,
+    handleEditorKeydown: c(e.handleEditorKeydown),
+    commitInlineEdit: c(e.commitInlineEdit),
+    cancelInlineEdit: c(e.cancelInlineEdit)
+  })), v = m(() => ({
+    cellClass: c(e.cellClass),
+    cellStyle: c(e.cellStyle),
+    isCellSelected: c(e.isCellSelected),
+    isSelectionAnchorCell: c(e.isSelectionAnchorCell),
+    shouldHighlightSelectedCell: c(e.shouldHighlightSelectedCell),
+    isCellOnSelectionEdge: c(e.isCellOnSelectionEdge),
+    isCellInFillPreview: c(e.isCellInFillPreview),
+    isCellInPendingClipboardRange: c(e.isCellInPendingClipboardRange),
+    isCellOnPendingClipboardEdge: c(e.isCellOnPendingClipboardEdge),
+    isCellEditable: c(e.isCellEditable),
+    readCell: c(e.readCell),
+    readDisplayCell: c(e.readDisplayCell)
+  })), R = m(() => ({
+    handleCellMouseDown: c(e.handleCellMouseDown),
+    handleCellClick: c(e.handleCellClick),
+    handleCellKeydown: c(e.handleCellKeydown)
+  })), y = m(() => ({
+    mode: c(e.mode),
+    rowHeightMode: c(e.rowHeightMode),
+    layout: s.value,
+    viewport: i.value,
+    columns: w.value,
+    rows: C.value,
+    selection: b.value,
+    editing: A.value,
+    cells: v.value,
+    interaction: R.value
+  })), g = ul({
+    mode: m(() => c(e.mode)),
+    rowHeightMode: m(() => c(e.rowHeightMode)),
+    layout: s,
+    viewport: i,
+    columns: w,
+    rows: C,
+    selection: b,
+    editing: A,
+    cells: v,
+    interaction: R
+  });
+  return {
+    tableStageProps: y,
+    tableStageContext: g,
+    captureHeaderViewportRef: o,
+    captureBodyViewportRef: r,
+    updateEditingCellValue: l
+  };
+}
+function xl(e) {
+  return {
+    readStageCell: (s, i) => e.isRowSelectionColumnKey(i) ? e.readRowSelectionCell(s) : e.readCell(s, i),
+    readStageDisplayCell: (s, i) => e.isRowSelectionColumnKey(i) ? e.readRowSelectionDisplayCell(s) : e.readDisplayCell(s, i),
+    handleCellClick: (s, i, w, C) => {
+      if (e.isRowSelectionColumn(w)) {
+        e.toggleRowCheckboxSelected(s);
+        return;
+      }
+      const b = e.viewportRowStart.value + i, A = e.isCellEditableByKey(s, b, w.key, C);
+      if (Gn({
+        column: w.column,
+        row: s.kind !== "group" ? s.data : void 0,
+        editable: A
+      }) !== "toggle" || s.kind === "group" || s.rowId == null)
+        return;
+      const R = e.captureHistorySnapshot();
+      e.runtime.api.rows.applyEdits([
+        {
+          rowId: s.rowId,
+          data: {
+            [w.key]: Pn({
+              column: w.column,
+              row: s.data
+            })
+          }
+        }
+      ]), e.recordHistoryIntentTransaction({
+        intent: "edit",
+        label: `Toggle ${w.key}`,
+        affectedRange: {
+          startRow: b,
+          endRow: b,
+          startColumn: C,
+          endColumn: C
+        }
+      }, R), e.syncViewport();
+    }
+  };
+}
+const pn = 140, bt = 108, dn = "__datagrid_row_selection__";
+function Al(e) {
+  const o = m(() => (e.showRowSelection?.value ?? !0) && e.runtime.api.rowSelection.hasSupport()), r = m(() => o.value ? {
+    key: dn,
+    state: {
+      visible: !0,
+      pin: "left",
+      width: bt
+    },
+    visible: !0,
+    pin: "left",
+    width: bt,
+    column: {
+      key: dn,
+      label: "",
+      cellType: "checkbox",
+      minWidth: bt,
+      maxWidth: bt,
+      capabilities: {
+        editable: !0,
+        sortable: !1,
+        filterable: !1,
+        groupable: !1,
+        pivotable: !1,
+        aggregatable: !1
+      },
+      presentation: {
+        align: "center",
+        headerAlign: "center"
+      },
+      meta: {
+        isSystem: !0,
+        rowSelection: !0
+      }
+    }
+  } : null), l = (g) => g === dn, s = (g) => l(g.key), i = m(() => {
+    const g = r.value, f = e.visibleColumns.value.filter((x) => x.pin === "left"), M = e.visibleColumns.value.filter((x) => x.pin !== "left" && x.pin !== "right"), I = e.visibleColumns.value.filter((x) => x.pin === "right");
+    return g ? [g, ...f, ...M, ...I] : [...f, ...M, ...I];
+  }), w = m(() => i.value.filter((g) => g.pin !== "left" && g.pin !== "right")), C = (g) => g.width ?? pn, b = (g) => {
+    const f = i.value.find((x) => x.key === g), I = `${f ? C(f) : pn}px`;
+    return {
+      width: I,
+      minWidth: I,
+      maxWidth: I
+    };
+  }, A = (g) => g.column.capabilities?.editable !== !1, v = (g, f, M) => s(M) ? g.kind !== "group" && g.rowId != null : g.kind === "group" || g.rowId == null || !A(M) ? !1 : e.isCellEditable ? e.isCellEditable({
+    row: g.data,
+    rowId: g.rowId,
+    rowIndex: f,
+    column: M.column,
+    columnKey: M.key
+  }) : !0, R = (g, f) => {
+    const M = i.value[f];
+    if (M?.key === g)
+      return { column: M, columnIndex: f };
+    const I = i.value.findIndex((x) => x.key === g);
+    return I < 0 ? null : {
+      column: i.value[I],
+      columnIndex: I
+    };
+  };
+  return {
+    orderedVisibleColumns: i,
+    centerColumns: w,
+    resolveColumnWidth: C,
+    stageColumnStyle: b,
+    isRowSelectionColumnKey: l,
+    isRowSelectionColumn: s,
+    isCellEditable: v,
+    isCellEditableByKey: (g, f, M, I) => {
+      const x = R(M, I);
+      return x ? v(g, f, x.column) : !1;
+    },
+    rowSelectionColumn: r
+  };
+}
+function Ol(e) {
+  const o = m(() => {
+    const l = e.lastAppliedFill.value, s = e.selectionRange.value;
+    return !l || !s || e.isFillDragging.value || l.allowBehaviorToggle === !1 || l.previewRange.startRow !== s.startRow || l.previewRange.endRow !== s.endRow || l.previewRange.startColumn !== s.startColumn || l.previewRange.endColumn !== s.endColumn ? null : {
+      rowIndex: l.previewRange.endRow,
+      columnIndex: l.previewRange.endColumn
+    };
+  }), r = m(() => e.lastAppliedFill.value?.behavior ?? null);
+  return {
+    fillActionAnchorCell: o,
+    fillActionBehavior: r
+  };
+}
+function Fl(e) {
+  const o = e.history ? null : Nn({
+    runtime: e.runtime,
+    cloneRowData: e.cloneRowData,
+    syncViewport: e.syncViewport
+  });
+  return {
+    captureHistorySnapshot: () => e.history ? e.history.captureSnapshot() : o?.captureRowsSnapshot() ?? null,
+    recordHistoryIntentTransaction: (b, A) => {
+      if (e.history) {
+        e.history.recordIntentTransaction(b, A);
+        return;
+      }
+      o?.recordIntentTransaction(
+        b,
+        A
+      );
+    },
+    canUndoHistory: () => e.history ? e.history.canUndo() : o?.canUndo.value ?? !1,
+    canRedoHistory: () => e.history ? e.history.canRedo() : o?.canRedo.value ?? !1,
+    runHistoryAction: (b) => e.history ? e.history.runHistoryAction(b) : o?.runHistoryAction(b) ?? Promise.resolve(null),
+    disposeIntentHistory: () => {
+      o?.dispose();
+    }
+  };
+}
+function Dl(e) {
+  const o = m(() => new Set(e.rowSelectionSnapshot.value?.selectedRows ?? [])), r = (f) => f.rowId != null && e.rowSelectionSnapshot.value?.focusedRow === f.rowId, l = (f) => f.kind !== "group" && f.rowId != null && o.value.has(f.rowId), s = (f) => l(f), i = (f) => s(f) ? "true" : "false", w = (f) => {
+    const M = e.rowSelectionColumn.value?.column;
+    return !M || f.kind === "group" ? "" : Ln({
+      column: M,
+      value: s(f)
+    }).displayValue;
+  }, C = m(() => {
+    const f = e.runtime.api.rows.getCount(), M = [];
+    for (let I = 0; I < f; I += 1) {
+      const x = e.runtime.api.rows.get(I);
+      !x || x.kind === "group" || x.rowId == null || M.push(x.rowId);
+    }
+    return M;
+  }), b = m(() => {
+    const f = C.value;
+    return f.length > 0 && f.every((M) => o.value.has(M));
+  }), A = m(() => C.value.some((M) => o.value.has(M))), v = (f) => {
+    f.rowId == null || !e.runtime.api.rowSelection.hasSupport() || e.runtime.api.rowSelection.setFocusedRow(f.rowId);
+  };
+  return {
+    rowSelectionSet: o,
+    isRowFocused: r,
+    isRowCheckboxSelected: l,
+    readRowSelectionCell: i,
+    readRowSelectionDisplayCell: w,
+    areAllVisibleRowsSelected: b,
+    areSomeVisibleRowsSelected: A,
+    focusRow: v,
+    toggleRowCheckboxSelected: (f) => {
+      f.kind === "group" || f.rowId == null || !e.runtime.api.rowSelection.hasSupport() || e.runtime.api.rowSelection.setSelected(f.rowId, !o.value.has(f.rowId));
+    },
+    toggleVisibleRowsSelected: () => {
+      if (!e.runtime.api.rowSelection.hasSupport())
+        return;
+      const f = C.value;
+      if (!b.value) {
+        e.runtime.api.rowSelection.selectRows(f);
+        return;
+      }
+      e.runtime.api.rowSelection.deselectRows(f);
+    },
+    selectRowRange: (f, M, I) => {
+      v(f);
+      const x = e.orderedVisibleColumns.value.length - 1;
+      if (x < 0)
+        return;
+      const N = e.viewportRowStart.value + M;
+      if (!I) {
+        e.applySelectionRange({
+          startRow: N,
+          endRow: N,
+          startColumn: 0,
+          endColumn: x
+        });
+        return;
+      }
+      const j = e.selectionAnchorCell.value?.rowIndex ?? N;
+      e.applySelectionRange({
+        startRow: Math.min(j, N),
+        endRow: Math.max(j, N),
+        startColumn: 0,
+        endColumn: x
+      });
+    }
+  };
+}
+function El(e) {
+  return {
+    handleWindowMouseMove: (i) => {
+      if (e.isColumnResizing.value) {
+        e.applyColumnResizeFromPointer(i.clientX);
+        return;
+      }
+      e.handleInteractionWindowMouseMove(i);
+    },
+    handleHeaderWheel: (i) => {
+      const w = e.bodyViewportRef.value;
+      if (!w)
+        return;
+      const C = Math.abs(i.deltaX) > 0 ? i.deltaX : i.shiftKey ? i.deltaY : 0, b = C === 0 ? i.deltaY : 0;
+      C === 0 && b === 0 || (i.preventDefault(), C !== 0 && (w.scrollLeft += C), b !== 0 && (w.scrollTop += b), e.syncViewport());
+    },
+    handleHeaderScroll: (i) => {
+      const w = i.target, C = e.bodyViewportRef.value;
+      !w || !C || (C.scrollLeft !== w.scrollLeft && (C.scrollLeft = w.scrollLeft), e.syncViewport());
+    },
+    handleWindowMouseUp: () => {
+      e.stopColumnResize(), e.handleInteractionWindowMouseUp();
+    }
+  };
+}
+function kl(e) {
+  const o = (i) => i.ctrlKey || i.metaKey || i.altKey ? !1 : i.key.startsWith("Arrow") || i.key === "Home" || i.key === "End" || i.key === "PageUp" || i.key === "PageDown" || i.key === "Tab" || i.key === "Enter" || i.key === " " || i.key === "Spacebar" || i.key === "F2" || i.key === "Escape" || i.key.length === 1, r = (i) => (i.ctrlKey || i.metaKey) && !i.altKey && !i.shiftKey && i.key.toLowerCase() === "a", l = () => {
+    const i = e.totalRows.value - 1, w = e.orderedVisibleColumns.value.length - 1;
+    i < 0 || w < 0 || e.applySelectionRange({
+      startRow: 0,
+      endRow: i,
+      startColumn: 0,
+      endColumn: w
+    });
+  };
+  return {
+    handleViewportKeydown: (i) => {
+      (o(i) || r(i)) && i.preventDefault();
+      const w = e.selectionSnapshot.value?.activeCell;
+      if (!w) {
+        r(i) && l();
+        return;
+      }
+      const C = e.runtime.getBodyRowAtIndex(w.rowIndex);
+      C && e.handleCellKeydown(
+        i,
+        C,
+        w.rowIndex - e.viewportRowStart.value,
+        w.colIndex
+      );
+    }
+  };
+}
+function Hl(e) {
+  const o = m(() => e.interactionSelectionRange.value ?? e.resolveCommittedSelectionRange()), r = () => {
+    const v = o.value;
+    return v && v.startRow === v.endRow && v.startColumn === v.endColumn ? {
+      rowIndex: v.startRow,
+      columnIndex: v.startColumn
+    } : e.selectionAnchorCell.value;
+  }, l = () => o.value, s = () => e.mode.value === "base" && e.isFillDragging.value && !!e.fillPreviewRange.value, i = (v, R, y) => {
+    const g = e.viewportRowStart.value + R;
+    return g >= v.startRow && g <= v.endRow && y >= v.startColumn && y <= v.endColumn;
+  }, w = (v, R) => {
+    const y = r();
+    return y ? y.rowIndex === e.viewportRowStart.value + v && y.columnIndex === R : e.isCommittedSelectionAnchorCell(v, R);
+  };
+  return {
+    selectionRange: o,
+    isSelectionAnchorCell: w,
+    isCellSelected: (v, R) => {
+      if (!s())
+        return e.isCommittedCellSelected(v, R);
+      const y = l();
+      return y ? i(y, v, R) : !1;
+    },
+    shouldHighlightSelectedCell: (v, R) => {
+      if (!s())
+        return e.shouldHighlightCommittedSelectedCell(v, R);
+      const y = l();
+      return !y || !i(y, v, R) || y.startRow === y.endRow && y.startColumn === y.endColumn ? !1 : !w(v, R);
+    },
+    isCellOnSelectionEdge: (v, R, y) => {
+      if (!s())
+        return e.isCommittedCellOnSelectionEdge(v, R, y);
+      const g = l();
+      if (!g || !i(g, v, R))
+        return !1;
+      const f = e.viewportRowStart.value + v;
+      switch (y) {
+        case "top":
+          return f === g.startRow;
+        case "right":
+          return R === g.endColumn;
+        case "bottom":
+          return f === g.endRow;
+        case "left":
+          return R === g.startColumn;
+      }
+    }
+  };
+}
+const mn = 140, Vl = 72, zl = 80, Tl = 24, jl = 400;
+function Bl(e) {
+  const o = e.syncRowSelectionSnapshotFromRuntime ?? (() => {
+  }), r = e.rowSelectionSnapshot ?? W(null), l = m(() => e.showRowIndex?.value !== !1), s = m(() => e.runtime.rowPartition.value.bodyRowCount), i = m(() => Math.max(0, e.totalRuntimeRows.value)), w = m(() => l.value ? Vl : 0), C = Al({
+    runtime: e.runtime,
+    visibleColumns: e.visibleColumns,
+    showRowSelection: e.showRowSelection,
+    isCellEditable: e.isCellEditable
+  }), {
+    orderedVisibleColumns: b,
+    centerColumns: A,
+    resolveColumnWidth: v,
+    isRowSelectionColumnKey: R,
+    isRowSelectionColumn: y,
+    isCellEditable: g,
+    isCellEditableByKey: f,
+    rowSelectionColumn: M
+  } = C, I = $n({
+    totalRows: () => s.value,
+    resolveBaseRowHeight: () => e.normalizedBaseRowHeight.value,
+    resolveRowHeightOverride: (t) => e.runtime.api.view.getRowHeightOverride(t),
+    resolveRowHeightVersion: () => e.runtime.api.view.getRowHeightVersion(),
+    hasRowHeightOverrides: () => e.runtime.api.view.getRowHeightVersion() > 0
+  });
+  let x = () => !1;
+  const {
+    headerViewportRef: N,
+    bodyViewportRef: j,
+    displayRows: ze,
+    pinnedBottomRows: pt,
+    renderedColumns: Mt,
+    viewportRowStart: H,
+    viewportColumnStart: It,
+    topSpacerHeight: xt,
+    bottomSpacerHeight: At,
+    leftColumnSpacerWidth: Ot,
+    rightColumnSpacerWidth: Ft,
+    gridContentStyle: Dt,
+    mainTrackStyle: he,
+    indexColumnStyle: Et,
+    columnStyle: kt,
+    handleViewportScroll: Ht,
+    syncViewportFromDom: V,
+    scheduleViewportSync: Vt,
+    cancelScheduledViewportSync: zt
+  } = Un({
+    runtime: e.runtime,
+    mode: e.mode,
+    rowRenderMode: e.rowRenderMode,
+    rowVirtualizationEnabled: m(() => e.virtualization.value.rows),
+    columnVirtualizationEnabled: m(() => e.virtualization.value.columns),
+    totalRows: s,
+    visibleColumns: A,
+    sizingColumns: b,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    resolveColumnWidth: v,
+    defaultColumnWidth: mn,
+    indexColumnWidth: 0,
+    flexFillOffsetWidth: w.value,
+    rowOverscan: m(() => e.virtualization.value.rowOverscan),
+    columnOverscan: m(() => e.virtualization.value.columnOverscan),
+    measureVisibleRowHeights: () => je(),
+    resolveRowHeight: I.resolveRowHeight,
+    resolveRowOffset: I.resolveRowOffset,
+    resolveRowIndexAtOffset: I.resolveRowIndexAtOffset,
+    resolveTotalRowHeight: I.resolveTotalHeight
+  }), Tt = (t) => kt(t), q = (t) => {
+    if (i.value <= 0)
+      return null;
+    const n = Math.max(0, Math.min(i.value - 1, Math.trunc(t)));
+    return e.runtime.api.rows.get(n) ?? null;
+  }, F = (t) => {
+    for (let n = 0; n < i.value; n += 1)
+      if (e.runtime.api.rows.get(n)?.rowId === t)
+        return n;
+    return e.runtime.resolveBodyRowIndexById(t);
+  }, L = {
+    ...e.runtime,
+    getBodyRowAtIndex: q,
+    resolveBodyRowIndexById: F
+  }, {
+    rowStyle: re,
+    isRowAutosizeProbe: Te,
+    measureVisibleRowHeights: je,
+    startRowResize: ie,
+    autosizeRow: Be,
+    dispose: _e
+  } = qn({
+    mode: e.mode,
+    rowHeightMode: e.rowHeightMode,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    viewportRowStart: H,
+    bodyViewportRef: j,
+    runtime: e.runtime,
+    minRowHeight: Tl,
+    syncViewport: () => V()
+  }), Q = Xn({
+    mode: e.mode,
+    runtime: L,
+    totalRows: i,
+    visibleColumns: b,
+    viewportRowStart: H,
+    selectionSnapshot: e.selectionSnapshot,
+    selectionAnchor: e.selectionAnchor,
+    isEditingCell: (t, n) => x(t, n)
+  }), {
+    normalizeRowId: Ge,
+    normalizeCellCoord: Pe,
+    resolveSelectionRange: ae,
+    resolveCurrentCellCoord: Le,
+    applySelectionRange: X,
+    applyCellSelectionByCoord: Re,
+    setCellSelection: G,
+    clearCellSelection: ye,
+    isCellSelected: Se
+  } = Q, We = Q.isSelectionAnchorCell ?? (() => !1), jt = Q.shouldHighlightSelectedCell ?? ((t, n) => Se(t, n)), Bt = Q.isCellOnSelectionEdge ?? (() => !1), pe = m(() => {
+    const t = e.selectionSnapshot.value;
+    if (!t || t.ranges.length === 0)
+      return null;
+    const n = t.activeRangeIndex ?? 0, a = t.ranges[n]?.anchor ?? t.ranges[0]?.anchor ?? null;
+    return !a || typeof a.rowIndex != "number" || typeof a.colIndex != "number" || !Number.isFinite(a.rowIndex) || !Number.isFinite(a.colIndex) ? null : {
+      rowIndex: Math.trunc(a.rowIndex),
+      columnIndex: Math.trunc(a.colIndex)
+    };
+  }), Ke = Dl({
+    runtime: e.runtime,
+    rowSelectionColumn: M,
+    orderedVisibleColumns: b,
+    displayRows: ze,
+    rowSelectionSnapshot: r,
+    viewportRowStart: H,
+    selectionAnchorCell: pe,
+    applySelectionRange: X
+  }), {
+    readRowSelectionCell: _t,
+    readRowSelectionDisplayCell: Gt,
+    toggleRowCheckboxSelected: Me
+  } = Ke, Pt = m(() => {
+    const t = `${w.value}px`;
+    return {
+      ...Et.value,
+      width: t,
+      minWidth: t,
+      maxWidth: t
+    };
+  }), Ne = Fl({
+    runtime: e.runtime,
+    cloneRowData: e.cloneRowData,
+    syncViewport: () => V(),
+    history: e.history
+  }), {
+    captureHistorySnapshot: ee,
+    recordHistoryIntentTransaction: te,
+    canUndoHistory: Lt,
+    canRedoHistory: $e,
+    runHistoryAction: Ue
+  } = Ne, {
+    rowIndexLabel: qe,
+    readCell: Xe,
+    readDisplayCell: Ye,
+    rowClass: Ie,
+    toggleGroupRow: ne
+  } = Yn({
+    mode: e.mode,
+    runtime: e.runtime,
+    viewportRowStart: H,
+    firstColumnKey: e.firstColumnKey
+  }), z = xl({
+    runtime: e.runtime,
+    viewportRowStart: H,
+    isRowSelectionColumnKey: R,
+    isRowSelectionColumn: y,
+    isCellEditableByKey: f,
+    readRowSelectionCell: _t,
+    readRowSelectionDisplayCell: Gt,
+    readCell: Xe,
+    readDisplayCell: Ye,
+    toggleRowCheckboxSelected: Me,
+    captureHistorySnapshot: ee,
+    recordHistoryIntentTransaction: te,
+    syncViewport: () => V()
+  }), {
+    readStageCell: se
+  } = z, xe = Jn({
+    mode: e.mode,
+    runtime: L,
+    totalRows: i,
+    visibleColumns: b,
+    viewportRowStart: H,
+    resolveSelectionRange: ae,
+    resolveCurrentCellCoord: Le,
+    applySelectionRange: X,
+    clearCellSelection: ye,
+    captureRowsSnapshot: ee,
+    recordEditTransaction: (t) => {
+      te({
+        intent: "edit",
+        label: "Cell edit"
+      }, t);
+    },
+    readCell: (t, n) => se(t, n),
+    readClipboardCell: e.readClipboardCell ? (t, n) => e.readClipboardCell?.(t, n) ?? "" : void 0,
+    isCellEditable: f,
+    syncViewport: () => V(),
+    applyClipboardEdits: e.applyClipboardEdits,
+    buildFillMatrixFromRange: e.buildFillMatrixFromRange
+  }), {
+    normalizeClipboardRange: Je,
+    applyClipboardEdits: Ze,
+    rangesEqual: Qe,
+    buildFillMatrixFromRange: Wt,
+    clearPendingClipboardOperation: et,
+    copySelectedCells: Ae,
+    pasteSelectedCells: tt,
+    cutSelectedCells: nt,
+    isCellInPendingClipboardRange: Kt,
+    isCellOnPendingClipboardEdge: lt
+  } = xe, {
+    ensureKeyboardActiveCellVisible: le
+  } = Zn({
+    bodyViewportRef: j,
+    visibleColumns: b,
+    resolveColumnWidth: v,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    resolveRowHeight: I.resolveRowHeight,
+    resolveRowOffset: I.resolveRowOffset,
+    indexColumnWidth: w.value,
+    defaultColumnWidth: mn,
+    syncViewport: () => V()
+  }), {
+    editingCell: Oe,
+    editingCellValue: ue,
+    editingCellInitialFilter: ce,
+    editingCellOpenOnMount: de,
+    isEditingCell: me,
+    startInlineEdit: ot,
+    commitInlineEdit: rt,
+    cancelInlineEdit: it,
+    handleEditorKeydown: Nt
+  } = Qn({
+    mode: e.mode,
+    bodyViewportRef: j,
+    visibleColumns: b,
+    totalRows: i,
+    runtime: L,
+    readCell: (t, n) => se(t, n),
+    resolveRowIndexById: F,
+    applyCellSelection: (t) => {
+      Re(t, !1);
+    },
+    ensureActiveCellVisible: (t, n) => {
+      le(t, n);
+    },
+    isCellEditable: f,
+    captureRowsSnapshot: ee,
+    recordEditTransaction: (t) => {
+      te({
+        intent: "edit",
+        label: "Cell edit"
+      }, t);
+    }
+  });
+  x = me;
+  const at = m(() => Oe.value), st = {
+    mode: e.mode,
+    runtime: L,
+    totalRows: i,
+    visibleColumns: b,
+    viewportRowStart: H,
+    selectionSnapshot: e.selectionSnapshot,
+    bodyViewportRef: j,
+    indexColumnWidth: w.value,
+    resolveColumnWidth: v,
+    resolveRowHeight: I.resolveRowHeight,
+    resolveRowIndexAtOffset: I.resolveRowIndexAtOffset,
+    normalizeRowId: Ge,
+    normalizeCellCoord: Pe,
+    resolveSelectionRange: ae,
+    applySelectionRange: X,
+    applyCellSelectionByCoord: Re,
+    setCellSelection: G,
+    clearCellSelection: ye,
+    readCell: (t, n) => se(t, n),
+    isCellEditable: f,
+    cloneRowData: e.cloneRowData,
+    resolveRowIndexById: F,
+    captureRowsSnapshot: ee,
+    recordIntentTransaction: (t, n) => {
+      te(t, n);
+    },
+    clearPendingClipboardOperation: et,
+    clearExternalPendingClipboardOperation: e.clearExternalPendingClipboardOperation,
+    copySelectedCells: Ae,
+    pasteSelectedCells: tt,
+    cutSelectedCells: nt,
+    normalizeClipboardRange: Je,
+    applyClipboardEdits: Ze,
+    rangesEqual: Qe,
+    buildFillMatrixFromRange: Wt,
+    applyRangeMove: e.applyRangeMove,
+    syncViewport: () => V(),
+    editingCell: at,
+    startInlineEdit: ot,
+    commitInlineEdit: rt,
+    canUndo: Lt,
+    canRedo: $e,
+    runHistoryAction: Ue,
+    ensureKeyboardActiveCellVisible: le,
+    isContextMenuVisible: e.isContextMenuVisible,
+    closeContextMenu: e.closeContextMenu,
+    openContextMenuFromCurrentCell: e.openContextMenuFromCurrentCell,
+    runRowIndexKeyboardAction: e.runRowIndexKeyboardAction,
+    handleToggleCellAction: (t, n, a, u) => y(u) ? (Me(t), !0) : !1
+  }, ut = el(st), {
+    isPointerSelectingCells: $t,
+    isFillDragging: we,
+    fillPreviewRange: ct,
+    lastAppliedFill: Ut,
+    isRangeMoving: dt,
+    selectionRange: mt,
+    rangeMovePreviewRange: wt,
+    stopPointerSelection: Fe,
+    stopFillSelection: qt,
+    startFillHandleDrag: De,
+    startFillHandleDoubleClick: ft,
+    applyLastFillBehavior: Xt,
+    handleCellMouseDown: Yt,
+    handleCellKeydown: Ct,
+    handleRowIndexKeydown: Jt,
+    handleWindowMouseMove: fe,
+    handleWindowMouseUp: Zt,
+    isCellInFillPreview: B,
+    isFillHandleCell: gt,
+    clearSelectedCells: Qt,
+    dispose: Y
+  } = ut, Ee = kl({
+    runtime: L,
+    selectionSnapshot: e.selectionSnapshot,
+    totalRows: i,
+    orderedVisibleColumns: b,
+    viewportRowStart: H,
+    applySelectionRange: X,
+    handleCellKeydown: Ct
+  }), {
+    isColumnResizing: en,
+    startResize: tn,
+    handleResizeDoubleClick: nn,
+    applyColumnResizeFromPointer: ln,
+    stopColumnResize: Ce,
+    dispose: on
+  } = tl({
+    visibleColumns: b,
+    rows: e.rows,
+    persistColumnWidth: (t, n) => {
+      e.runtime.api.columns.setWidth(t, n);
+    },
+    defaultColumnWidth: mn,
+    minColumnWidth: zl,
+    autoSizeSampleLimit: jl,
+    autoSizeCharWidth: 7.2,
+    autoSizeHorizontalPadding: 42,
+    autoSizeMaxWidth: 640,
+    isFillDragging: () => we.value,
+    stopFillSelection: () => {
+      qt(!1);
+    },
+    isDragSelecting: () => $t.value,
+    stopDragSelection: () => {
+      Fe();
+    },
+    readCellText: (t, n) => {
+      const a = t[n];
+      return a == null ? "" : String(a);
+    }
+  }), ke = Hl({
+    mode: e.mode,
+    viewportRowStart: H,
+    selectionAnchorCell: pe,
+    fillPreviewRange: ct,
+    isFillDragging: we,
+    interactionSelectionRange: mt,
+    resolveCommittedSelectionRange: ae,
+    isCommittedSelectionAnchorCell: We,
+    isCommittedCellSelected: Se,
+    shouldHighlightCommittedSelectedCell: jt,
+    isCommittedCellOnSelectionEdge: Bt
+  }), { selectionRange: vt } = ke, ge = Ol({
+    lastAppliedFill: Ut,
+    selectionRange: vt,
+    isFillDragging: we
+  }), rn = El({
+    bodyViewportRef: j,
+    isColumnResizing: en,
+    applyColumnResizeFromPointer: ln,
+    stopColumnResize: Ce,
+    handleInteractionWindowMouseMove: fe,
+    handleInteractionWindowMouseUp: Zt,
+    syncViewport: V
+  }), O = {
+    rowSelection: Ke,
+    history: Ne,
+    cellIo: z,
+    viewportKeyboard: Ee,
+    visualSelection: ke,
+    fillAction: ge,
+    scrollSync: rn
+  }, {
+    tableStageProps: an,
+    tableStageContext: sn
+  } = Il({
+    mode: e.mode,
+    rowHeightMode: e.rowHeightMode,
+    visibleColumns: b,
+    renderedColumns: Mt,
+    displayRows: ze,
+    pinnedBottomRows: pt,
+    sourceRows: e.sourceRows ?? e.rows,
+    showRowIndex: l,
+    rowHover: m(() => e.rowHover?.value === !0),
+    stripedRows: m(() => e.stripedRows?.value === !0),
+    columnFilterTextByKey: e.columnFilterTextByKey,
+    gridContentStyle: Dt,
+    mainTrackStyle: he,
+    indexColumnStyle: Pt,
+    topSpacerHeight: xt,
+    bottomSpacerHeight: At,
+    viewportRowStart: H,
+    columnWindowStart: It,
+    leftColumnSpacerWidth: Ot,
+    rightColumnSpacerWidth: Ft,
+    editingCellValueRef: ue,
+    editingCellInitialFilter: ce,
+    editingCellOpenOnMount: de,
+    selectionRange: vt,
+    selectionAnchorCell: pe,
+    fillPreviewRange: ct,
+    rangeMovePreviewRange: wt,
+    isFillDragging: we,
+    isRangeMoving: dt,
+    headerViewportRef: N,
+    bodyViewportRef: j,
+    columnStyle: Tt,
+    toggleSortForColumn: e.toggleSortForColumn,
+    sortIndicator: e.sortIndicator,
+    setColumnFilterText: e.setColumnFilterText,
+    columnMenuEnabled: e.columnMenuEnabled,
+    columnMenuValueFilterEnabled: e.columnMenuValueFilterEnabled,
+    columnMenuValueFilterRowLimit: e.columnMenuValueFilterRowLimit,
+    columnMenuMaxFilterValues: e.columnMenuMaxFilterValues,
+    resolveColumnMenuItems: e.resolveColumnMenuItems,
+    resolveColumnMenuDisabledItems: e.resolveColumnMenuDisabledItems,
+    resolveColumnMenuDisabledReasons: e.resolveColumnMenuDisabledReasons,
+    resolveColumnMenuLabels: e.resolveColumnMenuLabels,
+    resolveColumnMenuActionOptions: e.resolveColumnMenuActionOptions,
+    isColumnFilterActive: e.isColumnFilterActive,
+    isColumnGrouped: e.isColumnGrouped,
+    resolveColumnGroupOrder: e.resolveColumnGroupOrder,
+    resolveColumnMenuSortDirection: e.resolveColumnMenuSortDirection,
+    resolveColumnMenuSelectedTokens: e.resolveColumnMenuSelectedTokens,
+    applyColumnMenuSort: e.applyColumnMenuSort,
+    applyColumnMenuPin: e.applyColumnMenuPin,
+    applyColumnMenuGroupBy: e.applyColumnMenuGroupBy,
+    applyColumnMenuFilter: e.applyColumnMenuFilter,
+    clearColumnMenuFilter: e.clearColumnMenuFilter,
+    handleHeaderWheel: O.scrollSync.handleHeaderWheel,
+    handleHeaderScroll: O.scrollSync.handleHeaderScroll,
+    handleViewportScroll: Ht,
+    handleViewportKeydown: O.viewportKeyboard.handleViewportKeydown,
+    rowClass: Ie,
+    isRowAutosizeProbe: Te,
+    rowStyle: re,
+    isRowInPendingClipboardCut: e.isRowInPendingClipboardCut,
+    isRowFocused: O.rowSelection.isRowFocused,
+    isRowCheckboxSelected: O.rowSelection.isRowCheckboxSelected,
+    allVisibleRowsSelected: O.rowSelection.areAllVisibleRowsSelected,
+    someVisibleRowsSelected: O.rowSelection.areSomeVisibleRowsSelected,
+    handleRowClick: O.rowSelection.focusRow,
+    handleRowIndexClick: O.rowSelection.selectRowRange,
+    handleRowIndexKeydown: Jt,
+    handleToggleAllVisibleRows: O.rowSelection.toggleVisibleRowsSelected,
+    toggleGroupRow: ne,
+    rowIndexLabel: qe,
+    startResize: tn,
+    handleResizeDoubleClick: nn,
+    startRowResize: ie,
+    autosizeRow: Be,
+    isCellSelected: O.visualSelection.isCellSelected,
+    isSelectionAnchorCell: O.visualSelection.isSelectionAnchorCell,
+    shouldHighlightSelectedCell: O.visualSelection.shouldHighlightSelectedCell,
+    isCellOnSelectionEdge: O.visualSelection.isCellOnSelectionEdge,
+    isCellInFillPreview: B,
+    isCellInPendingClipboardRange: Kt,
+    isCellOnPendingClipboardEdge: lt,
+    isEditingCell: me,
+    isCellEditable: (t, n, a, u) => g(t, H.value + n, a),
+    handleCellMouseDown: Yt,
+    handleCellClick: O.cellIo.handleCellClick,
+    handleCellKeydown: Ct,
+    startInlineEdit: ot,
+    isFillHandleCell: gt,
+    startFillHandleDrag: De,
+    startFillHandleDoubleClick: ft,
+    fillActionAnchorCell: O.fillAction.fillActionAnchorCell,
+    fillActionBehavior: O.fillAction.fillActionBehavior,
+    applyFillActionBehavior: Xt,
+    handleEditorKeydown: Nt,
+    commitInlineEdit: rt,
+    cancelInlineEdit: it,
+    readCell: O.cellIo.readStageCell,
+    readDisplayCell: O.cellIo.readStageDisplayCell
+  });
+  return nl({
+    mode: e.mode,
+    rows: e.rows,
+    runtime: e.runtime,
+    totalRows: s,
+    rowVersion: e.rowVersion,
+    rowHeightMode: e.rowHeightMode,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    syncSelectionSnapshotFromRuntime: e.syncSelectionSnapshotFromRuntime,
+    syncRowSelectionSnapshotFromRuntime: o,
+    syncViewport: V,
+    scheduleViewportSync: Vt,
+    measureVisibleRowHeights: je,
+    applyRowHeightSettings: e.applyRowHeightSettings
+  }), ll({
+    bodyViewportRef: j,
+    syncViewport: V,
+    handleWindowMouseMove: O.scrollSync.handleWindowMouseMove,
+    handleWindowMouseUp: O.scrollSync.handleWindowMouseUp,
+    cancelScheduledViewportSync: zt,
+    onAfterMount: () => {
+      e.syncSelectionSnapshotFromRuntime(), o(), Dn(() => {
+        e.applyRowHeightSettings(), V();
+      });
+    },
+    dispose: [
+      _e,
+      on,
+      Y,
+      O.history.disposeIntentHistory
+    ]
+  }), {
+    tableStageProps: an,
+    tableStageContext: sn,
+    syncViewportFromDom: V,
+    copySelectedCells: Ae,
+    pasteSelectedCells: tt,
+    cutSelectedCells: nt,
+    clearSelectedCells: Qt,
+    captureHistorySnapshot: ee,
+    recordHistoryIntentTransaction: te
+  };
+}
+const _l = yt(() => import("./DataGridColumnLayoutPopover-Qt56b3CA.js")), Gl = yt(() => import("./DataGridAdvancedFilterPopover-Bak_CkaO.js")), Pl = yt(() => import("./DataGridAggregationsPopover-DfQ3-UV4.js")), Ll = yt(() => import("./DataGridGanttStageEntry-B9YlOHt1.js"));
+function Wl(e) {
+  return Number.isFinite(e) ? Math.max(24, Math.trunc(e)) : 31;
+}
+function Kl(e) {
+  return typeof CSS < "u" && typeof CSS.escape == "function" ? CSS.escape(e) : e.replace(/\\/g, "\\\\").replace(/\"/g, '\\"');
+}
+function Mn(e) {
+  return (e ?? []).map((o) => ({
+    key: o.key,
+    direction: o.direction
+  }));
+}
+function Cn() {
+  return {
+    columnFilters: {},
+    advancedFilters: {},
+    advancedExpression: null
+  };
+}
+function He(e) {
+  return Kn(e ?? Cn()) ?? Cn();
+}
+function gn(e) {
+  return e.startsWith("string:") ? `string:${e.slice(7).toLowerCase()}` : e;
+}
+function Nl(e) {
+  const o = {};
+  for (const [s, i] of Object.entries(e.columnFilters ?? {})) {
+    if (i.kind === "valueSet") {
+      const w = Array.from(new Set(
+        (i.tokens ?? []).map((C) => gn(String(C ?? ""))).filter((C) => C.length > 0)
+      ));
+      if (w.length === 0)
+        continue;
+      o[s] = {
+        kind: "valueSet",
+        tokens: w
+      };
+      continue;
+    }
+    o[s] = {
+      kind: "predicate",
+      operator: i.operator,
+      value: i.value,
+      value2: i.value2,
+      caseSensitive: i.caseSensitive
+    };
+  }
+  const r = { ...e.advancedFilters ?? {} }, l = e.advancedExpression ?? null;
+  return Object.keys(o).length === 0 && Object.keys(r).length === 0 && !l ? null : {
+    columnFilters: o,
+    advancedFilters: r,
+    advancedExpression: l
+  };
+}
+function $l(e) {
+  const o = {}, r = e?.columnFilters ?? {};
+  for (const [l, s] of Object.entries(r))
+    s?.kind === "predicate" && typeof s.value == "string" && (o[l] = s.value);
+  return o;
+}
+function J(e) {
+  if (typeof globalThis.structuredClone == "function")
+    try {
+      return globalThis.structuredClone(e);
+    } catch {
+    }
+  return vn(e, /* @__PURE__ */ new WeakMap());
+}
+function vn(e, o) {
+  if (e == null || typeof e != "object")
+    return e;
+  if (e instanceof Date)
+    return new Date(e.getTime());
+  if (Array.isArray(e)) {
+    if (o.has(e))
+      return o.get(e);
+    const r = [];
+    o.set(e, r);
+    for (const l of e)
+      r.push(vn(l, o));
+    return r;
+  }
+  if (Bn(e)) {
+    if (o.has(e))
+      return o.get(e);
+    const r = {};
+    o.set(e, r);
+    for (const [l, s] of Object.entries(e))
+      r[l] = vn(s, o);
+    return r;
+  }
+  return e && typeof e == "object" ? { ...e } : e;
+}
+function Bn(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const o = Object.getPrototypeOf(e);
+  return o === Object.prototype || o === null;
+}
+function Ul(e) {
+  const o = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(e, (r, l) => {
+      if (l == null || typeof l != "object")
+        return l;
+      if (l instanceof Date)
+        return l.toISOString();
+      if (Array.isArray(l) || Bn(l))
+        return o.has(l) ? void 0 : (o.add(l), l);
+    });
+  } catch {
+    return null;
+  }
+}
+function Ve(e) {
+  return e ? {
+    columns: e.columns.map((o) => ({ ...o })),
+    basis: e.basis === "source" ? "source" : "filtered"
+  } : null;
+}
+function ql(e) {
+  return e ? {
+    fields: [...e.fields],
+    expandedByDefault: e.expandedByDefault
+  } : null;
+}
+function U(e) {
+  return e == null ? "blank" : e instanceof Date ? e.toISOString() : typeof e == "string" ? `"${e}"` : String(e);
+}
+function oe(e) {
+  switch (e) {
+    case "contains":
+      return "contains";
+    case "startsWith":
+    case "starts-with":
+      return "starts with";
+    case "endsWith":
+    case "ends-with":
+      return "ends with";
+    case "equals":
+      return "=";
+    case "notEquals":
+    case "not-equals":
+      return "!=";
+    case "gt":
+      return ">";
+    case "gte":
+      return ">=";
+    case "lt":
+      return "<";
+    case "lte":
+      return "<=";
+    case "between":
+      return "between";
+    case "isEmpty":
+    case "is-empty":
+      return "is empty";
+    case "notEmpty":
+    case "not-empty":
+      return "is not empty";
+    case "isNull":
+    case "is-null":
+      return "is null";
+    case "notNull":
+    case "not-null":
+      return "is not null";
+    default:
+      return e;
+  }
+}
+function Xl(e) {
+  const o = String(e ?? "");
+  if (o === "null")
+    return "(Blanks)";
+  const r = o.indexOf(":");
+  if (r < 0)
+    return o;
+  const l = o.slice(0, r), s = o.slice(r + 1);
+  return l === "string" || l === "number" || l === "boolean" || l === "bigint" || l === "date" || l === "repr" || l === "json" ? s : o;
+}
+function Yl(e, o) {
+  return o.kind === "valueSet" ? o.tokens.length === 1 ? `${e}: ${Xl(o.tokens[0] ?? "")}` : `${e}: ${o.tokens.length} values` : o.operator === "between" ? `${e} between ${U(o.value)} and ${U(o.value2)}` : o.operator === "isEmpty" || o.operator === "notEmpty" || o.operator === "isNull" || o.operator === "notNull" ? `${e} ${oe(o.operator)}` : `${e} ${oe(o.operator)} ${U(o.value)}`;
+}
+function Jl(e, o) {
+  const r = o.clauses.map((l, s) => {
+    const i = s === 0 ? "" : `${String(l.join ?? "and").toUpperCase()} `;
+    return l.operator === "between" ? `${i}${oe(l.operator)} ${U(l.value)} and ${U(l.value2)}` : l.operator === "isEmpty" || l.operator === "notEmpty" || l.operator === "isNull" || l.operator === "notNull" ? `${i}${oe(l.operator)}` : `${i}${oe(l.operator)} ${U(l.value)}`;
+  }).filter((l) => l.length > 0);
+  return r.length === 0 ? `${e}: active` : `${e} ${r.join(" ")}`;
+}
+function bn(e, o) {
+  if (e.kind === "condition") {
+    const r = o(e.key);
+    return e.operator === "between" ? `${r} between ${U(e.value)} and ${U(e.value2)}` : e.operator === "isEmpty" || e.operator === "notEmpty" || e.operator === "isNull" || e.operator === "notNull" ? `${r} ${oe(e.operator)}` : `${r} ${oe(e.operator)} ${U(e.value)}`;
+  }
+  return e.kind === "not" ? `NOT (${bn(e.child, o)})` : e.children.map((r) => bn(r, o)).filter((r) => r.length > 0).join(` ${e.operator.toUpperCase()} `);
+}
+const Zl = [
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count",
+  "countNonNull",
+  "first",
+  "last"
+], Ql = [
+  "min",
+  "max",
+  "count",
+  "countNonNull",
+  "first",
+  "last"
+], eo = [
+  "count",
+  "countNonNull",
+  "first",
+  "last"
+];
+function to(e) {
+  return e === "number" || e === "currency" || e === "percent" ? Zl : e === "date" || e === "datetime" ? Ql : eo;
+}
+const no = {
+  clipboard: ["cut", "copy", "paste"],
+  edit: ["clear"]
+}, lo = {
+  insert: ["insert-row-above", "insert-row-below"],
+  clipboard: ["cut-row", "copy-row", "paste-row"],
+  selection: ["delete-selected-rows"]
+}, In = {
+  cut: "Cut",
+  copy: "Copy",
+  paste: "Paste",
+  clear: "Clear values",
+  "insert-row-above": "Insert above",
+  "insert-row-below": "Insert below",
+  "copy-row": "Copy row",
+  "paste-row": "Paste row",
+  "cut-row": "Cut row",
+  "delete-selected-rows": "Delete selected rows",
+  "sort-asc": "Sort ascending",
+  "sort-desc": "Sort descending",
+  "sort-clear": "Clear sort",
+  filter: "Filter column",
+  "auto-size": "Auto size column"
+}, oo = {
+  "insert-row-above": "Insert / Ctrl/Cmd+I",
+  "copy-row": "Ctrl/Cmd+C",
+  "paste-row": "Ctrl/Cmd+V",
+  "cut-row": "Ctrl/Cmd+X"
+}, So = Fn({
+  name: "DataGridDefaultRenderer",
+  props: {
+    mode: {
+      type: String,
+      required: !0
+    },
+    rows: {
+      type: Array,
+      default: () => []
+    },
+    runtime: {
+      type: Object,
+      required: !0
+    },
+    runtimeRowModel: {
+      type: Object,
+      required: !0
+    },
+    selectionSnapshot: {
+      type: Object,
+      required: !0
+    },
+    selectionAnchor: {
+      type: Object,
+      required: !0
+    },
+    rowSelectionSnapshot: {
+      type: Object,
+      required: !0
+    },
+    syncSelectionSnapshotFromRuntime: {
+      type: Function,
+      required: !0
+    },
+    syncRowSelectionSnapshotFromRuntime: {
+      type: Function,
+      default: () => {
+      }
+    },
+    sortModel: {
+      type: Array,
+      default: void 0
+    },
+    filterModel: {
+      type: Object,
+      default: void 0
+    },
+    groupBy: {
+      type: Object,
+      default: void 0
+    },
+    pivotModel: {
+      type: Object,
+      default: void 0
+    },
+    renderMode: {
+      type: String,
+      default: "virtualization"
+    },
+    virtualization: {
+      type: Object,
+      required: !0
+    },
+    columnMenu: {
+      type: Object,
+      required: !0
+    },
+    cellMenu: {
+      type: Object,
+      required: !0
+    },
+    rowIndexMenu: {
+      type: Object,
+      required: !0
+    },
+    columnLayout: {
+      type: Object,
+      required: !0
+    },
+    aggregations: {
+      type: Object,
+      required: !0
+    },
+    advancedFilter: {
+      type: Object,
+      required: !0
+    },
+    rowHeightMode: {
+      type: String,
+      default: "fixed"
+    },
+    baseRowHeight: {
+      type: Number,
+      default: 31
+    },
+    rowHover: {
+      type: Boolean,
+      default: !1
+    },
+    stripedRows: {
+      type: Boolean,
+      default: !1
+    },
+    showRowIndex: {
+      type: Boolean,
+      default: !0
+    },
+    rowSelection: {
+      type: Boolean,
+      default: !0
+    },
+    isCellEditable: {
+      type: Function,
+      default: void 0
+    },
+    viewMode: {
+      type: String,
+      default: "table"
+    },
+    gantt: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    toolbarModules: {
+      type: Array,
+      default: () => []
+    },
+    inspectorPanel: {
+      type: Object,
+      default: null
+    }
+  },
+  setup(e) {
+    const o = W(0), r = W(Mn(e.sortModel)), l = W(He(e.filterModel)), s = m(() => $l(l.value));
+    let i = "";
+    const w = () => {
+      const t = e.runtimeRowModel.getSnapshot();
+      return [
+        t.kind,
+        t.revision ?? "",
+        t.rowCount,
+        t.loading ? 1 : 0,
+        t.projection?.recomputeVersion ?? t.projection?.version ?? ""
+      ].join("|");
+    };
+    i = w();
+    const C = e.runtimeRowModel.subscribe(() => {
+      const t = w();
+      t !== i && (i = t, o.value += 1);
+    });
+    En(() => {
+      C();
+    }), K(
+      () => e.sortModel,
+      (t) => {
+        r.value = Mn(t);
+      },
+      { deep: !0 }
+    ), K(
+      () => e.filterModel,
+      (t) => {
+        l.value = He(t);
+      },
+      { deep: !0 }
+    );
+    const b = m(() => e.mode), A = m(() => e.rows), v = m(() => (o.value, e.runtime.api.rows.getSnapshot().rowCount)), R = m(() => e.runtime.columnSnapshot.value.visibleColumns), y = m(() => e.runtime.columnSnapshot.value.columns ?? []), g = m(() => R.value.filter((t) => t.visible !== !1).map((t) => ({
+      key: t.key,
+      label: t.column.label ?? t.key
+    }))), f = m(() => y.value.map((t) => ({
+      key: t.key,
+      label: t.column.label ?? t.key,
+      visible: t.visible !== !1
+    }))), M = m(() => y.value.filter((t) => t.column.capabilities?.aggregatable === !0).map((t) => ({
+      key: t.key,
+      label: t.column.label ?? t.key,
+      allowedOps: to(t.column.dataType)
+    }))), I = W(e.rowHeightMode), x = m(() => Wl(e.baseRowHeight)), N = m(() => R.value[0]?.key ?? "name"), j = m(() => {
+      const t = /* @__PURE__ */ new Map();
+      for (const n of y.value)
+        t.set(n.key, n.column.label ?? n.key);
+      return t;
+    }), {
+      isColumnLayoutPanelOpen: ze,
+      columnLayoutPanelItems: pt,
+      openColumnLayoutPanel: Mt,
+      cancelColumnLayoutPanel: H,
+      applyColumnLayoutPanel: It,
+      moveColumnUp: xt,
+      moveColumnDown: At,
+      updateColumnVisibility: Ot
+    } = ol({
+      resolveColumns: () => f.value,
+      applyColumnLayout: (t) => {
+        e.runtime.api.columns.setOrder(t.order);
+        for (const [n, a] of Object.entries(t.visibilityByKey))
+          e.runtime.api.columns.setVisibility(n, a);
+      }
+    }), {
+      isAdvancedFilterPanelOpen: Ft,
+      advancedFilterDraftClauses: Dt,
+      appliedAdvancedFilterExpression: he,
+      openAdvancedFilterPanel: Et,
+      addAdvancedFilterClause: kt,
+      removeAdvancedFilterClause: Ht,
+      updateAdvancedFilterClause: V,
+      cancelAdvancedFilterPanel: Vt,
+      applyAdvancedFilterPanel: zt,
+      clearAdvancedFilterPanel: Tt
+    } = rl({
+      resolveColumns: () => g.value
+    }), q = W(!1), F = W(null), L = m(() => !!e.groupBy?.fields?.length), re = m(() => (o.value, Ve(e.runtime.api.rows.getAggregationModel()))), Te = m(() => (o.value, ql(e.runtime.api.rows.getSnapshot().groupBy))), je = m(() => {
+      const t = new Map(
+        (F.value?.columns ?? []).map((n) => [n.key, n.op])
+      );
+      return M.value.map((n) => {
+        const a = n.allowedOps[0] ?? "count", u = t.get(n.key), d = u && n.allowedOps.includes(u) ? u : a;
+        return {
+          key: n.key,
+          label: n.label,
+          enabled: t.has(n.key),
+          op: d,
+          allowedOps: n.allowedOps
+        };
+      });
+    }), ie = m(() => F.value?.basis === "source" ? "source" : "filtered");
+    K(
+      re,
+      (t) => {
+        q.value || (F.value = Ve(t));
+      },
+      { immediate: !0, deep: !0 }
+    ), K(
+      () => e.rowHeightMode,
+      (t) => {
+        I.value = t;
+      }
+    );
+    const Be = (t) => {
+      const n = l.value.columnFilters?.[t];
+      return n ? n.kind === "valueSet" ? n.tokens.length > 0 : !0 : !1;
+    }, _e = (t) => {
+      const n = l.value.columnFilters?.[t];
+      return !n || n.kind !== "valueSet" ? [] : n.tokens.map((a) => gn(String(a ?? "")));
+    }, Q = (t) => Tn(e.columnMenu, t), Ge = (t) => wl(e.columnMenu, t), Pe = (t) => Cl(e.columnMenu, t), ae = (t) => fl(e.columnMenu, t), Le = (t) => gl(e.columnMenu, t), X = (t) => {
+      const n = Te.value?.fields.findIndex((a) => a === t) ?? -1;
+      return n >= 0 ? n : null;
+    }, Re = (t) => X(t) !== null, G = () => {
+      const t = r.value.map((a) => ({
+        key: a.key,
+        direction: a.direction
+      })), n = e.advancedFilter.enabled ? he.value : l.value.advancedExpression ?? null;
+      e.runtime.api.rows.setSortAndFilterModel({
+        sortModel: t,
+        filterModel: Nl({
+          ...l.value,
+          advancedExpression: n
+        })
+      });
+    }, ye = m(() => e.advancedFilter.enabled ? he.value ?? l.value.advancedExpression ?? null : l.value.advancedExpression ?? null), Se = m(() => {
+      const t = (a) => j.value.get(a) ?? a, n = [];
+      for (const [a, u] of Object.entries(l.value.columnFilters ?? {}))
+        u && n.push(Yl(t(a), u));
+      for (const [a, u] of Object.entries(l.value.advancedFilters ?? {}))
+        u && n.push(`Advanced: ${Jl(t(a), u)}`);
+      return ye.value && n.push(`Advanced: ${bn(ye.value, t)}`), Object.freeze(n);
+    }), We = m(() => Se.value.length > 0), jt = () => {
+      l.value = Cn(), Tt(), G();
+    };
+    K(
+      he,
+      () => {
+        e.advancedFilter.enabled && G();
+      },
+      { deep: !0 }
+    );
+    const Bt = (t, n = !1) => {
+      const a = r.value.findIndex((d) => d.key === t), u = a >= 0 ? r.value[a] : null;
+      if (!u) {
+        const d = { key: t, direction: "asc" };
+        r.value = n ? [...r.value, d] : [d], G();
+        return;
+      }
+      if (u.direction === "asc") {
+        const d = { key: t, direction: "desc" };
+        n ? r.value = r.value.map((h) => h.key === t ? d : h) : r.value = [d], G();
+        return;
+      }
+      r.value = n ? r.value.filter((d) => d.key !== t) : [], G();
+    }, pe = (t) => {
+      const n = r.value.findIndex((d) => d.key === t);
+      if (n < 0)
+        return "";
+      const a = r.value[n];
+      if (!a)
+        return "";
+      const u = a.direction === "asc" ? "↑" : "↓";
+      return r.value.length > 1 ? `${u}${n + 1}` : u;
+    }, Ke = (t, n) => {
+      const a = He(l.value), u = n.trim();
+      u ? a.columnFilters[t] = {
+        kind: "predicate",
+        operator: "contains",
+        value: u,
+        caseSensitive: !1
+      } : delete a.columnFilters[t], l.value = a, G();
+    }, _t = () => {
+      e.runtime.api.view.setRowHeightMode(I.value), e.runtime.api.view.setBaseRowHeight(x.value);
+    }, Gt = () => {
+      F.value = Ve(re.value), q.value = !0;
+    }, Me = () => {
+      F.value = Ve(re.value), q.value = !1;
+    };
+    K(
+      L,
+      (t) => {
+        t || Me();
+      },
+      { immediate: !0 }
+    );
+    const Pt = () => {
+      F.value = null;
+    }, Ne = (t) => {
+      F.value = {
+        basis: t,
+        columns: F.value?.columns ?? []
+      };
+    }, ee = (t, n) => {
+      const a = M.value.find((S) => S.key === t);
+      if (!a)
+        return;
+      const u = F.value?.columns ?? [];
+      if (!n) {
+        const S = u.filter((D) => D.key !== t);
+        F.value = S.length > 0 ? { basis: ie.value, columns: S } : null;
+        return;
+      }
+      const h = u.find((S) => S.key === t) ?? {
+        key: t,
+        op: a.allowedOps[0] ?? "count"
+      };
+      F.value = {
+        basis: ie.value,
+        columns: [
+          ...u.filter((S) => S.key !== t),
+          h
+        ]
+      };
+    }, te = (t, n) => {
+      const a = M.value.find((d) => d.key === t);
+      if (!a || !a.allowedOps.includes(n))
+        return;
+      const u = (F.value?.columns ?? []).map((d) => d.key !== t ? d : {
+        ...d,
+        op: n
+      });
+      F.value = {
+        basis: ie.value,
+        columns: u
+      };
+    }, Lt = () => {
+      const t = F.value && F.value.columns.length > 0 ? F.value : null;
+      e.runtime.api.rows.setAggregationModel(t), F.value = Ve(t), q.value = !1;
+    }, $e = (t) => r.value.find((n) => n.key === t)?.direction ?? null, Ue = (t, n) => {
+      const a = R.value.find((u) => u.key === t);
+      !a || a.column.capabilities?.sortable === !1 || (r.value = n === null ? r.value.filter((u) => u.key !== t) : [{ key: t, direction: n }], G());
+    }, qe = (t, n) => {
+      e.runtime.api.columns.setPin(t, n);
+    }, Xe = (t, n) => {
+      const a = Te.value, u = n ? Array.from(/* @__PURE__ */ new Set([...a?.fields ?? [], t])) : (a?.fields ?? []).filter((d) => d !== t);
+      e.runtime.api.rows.setGroupBy(u.length > 0 ? {
+        fields: u,
+        expandedByDefault: a?.expandedByDefault ?? !0
+      } : null);
+    }, Ye = (t, n) => {
+      const a = Array.from(new Set(
+        n.map((d) => gn(String(d ?? ""))).filter((d) => d.length > 0)
+      ));
+      if (a.length === 0) {
+        Ie(t);
+        return;
+      }
+      const u = He(l.value);
+      u.columnFilters[t] = {
+        kind: "valueSet",
+        tokens: a
+      }, l.value = u, G();
+    }, Ie = (t) => {
+      const n = He(l.value);
+      delete n.columnFilters[t], l.value = n, G();
+    }, ne = W(null), z = W(null);
+    let se = 0;
+    const xe = () => {
+      const t = e.selectionSnapshot.value, n = t?.ranges[t.activeRangeIndex] ?? null;
+      return n ? {
+        startRow: n.startRow,
+        endRow: n.endRow,
+        startColumn: n.startCol,
+        endColumn: n.endCol
+      } : null;
+    }, Je = () => {
+      const t = e.selectionSnapshot.value?.activeCell;
+      return t ? {
+        rowIndex: t.rowIndex,
+        columnIndex: t.colIndex
+      } : null;
+    }, Ze = (t) => t ? t.startRow !== t.endRow || t.startColumn !== t.endColumn : !1, Qe = (t, n) => t.rowIndex >= Math.min(n.startRow, n.endRow) && t.rowIndex <= Math.max(n.startRow, n.endRow) && t.columnIndex >= Math.min(n.startColumn, n.endColumn) && t.columnIndex <= Math.max(n.startColumn, n.endColumn), Wt = (t, n) => {
+      const a = e.runtime.resolveBodyRowIndexById(t), u = R.value.findIndex((d) => d.key === n);
+      return a < 0 || u < 0 ? null : { rowIndex: a, columnIndex: u };
+    }, et = (t) => ({
+      ranges: [{
+        startRow: t.rowIndex,
+        endRow: t.rowIndex,
+        startCol: t.columnIndex,
+        endCol: t.columnIndex,
+        anchor: {
+          rowIndex: t.rowIndex,
+          colIndex: t.columnIndex,
+          rowId: e.runtime.getBodyRowAtIndex(t.rowIndex)?.rowId ?? null
+        },
+        focus: {
+          rowIndex: t.rowIndex,
+          colIndex: t.columnIndex,
+          rowId: e.runtime.getBodyRowAtIndex(t.rowIndex)?.rowId ?? null
+        },
+        startRowId: e.runtime.getBodyRowAtIndex(t.rowIndex)?.rowId ?? null,
+        endRowId: e.runtime.getBodyRowAtIndex(t.rowIndex)?.rowId ?? null
+      }],
+      activeRangeIndex: 0,
+      activeCell: {
+        rowIndex: t.rowIndex,
+        colIndex: t.columnIndex,
+        rowId: e.runtime.getBodyRowAtIndex(t.rowIndex)?.rowId ?? null
+      }
+    }), Ae = (t) => {
+      const n = e.runtime.api.rows.getCount();
+      for (let a = 0; a < n; a += 1) {
+        const u = e.runtime.api.rows.get(a);
+        if (u && String(u.rowId) === t)
+          return u;
+      }
+      return null;
+    }, tt = async (t) => {
+      try {
+        return globalThis.navigator?.clipboard?.writeText ? (await globalThis.navigator.clipboard.writeText(t), !0) : !1;
+      } catch {
+        return !1;
+      }
+    }, nt = async () => {
+      try {
+        return globalThis.navigator?.clipboard?.readText ? await globalThis.navigator.clipboard.readText() : "";
+      } catch {
+        return "";
+      }
+    }, Kt = async () => {
+      if (z.value?.rows.length)
+        return z.value.rows.map((n) => J(n));
+      const t = (await nt()).trim();
+      if (!t)
+        return null;
+      try {
+        const n = JSON.parse(t);
+        if (Array.isArray(n))
+          return n.filter((a) => !!a && typeof a == "object").map((a) => J(a));
+        if (n && typeof n == "object")
+          return [J(n)];
+      } catch {
+        return null;
+      }
+      return null;
+    }, lt = async (t, n, a = []) => {
+      const u = t.map((h) => J(h));
+      z.value = {
+        rows: u,
+        operation: n,
+        sourceRowIds: a.map((h) => String(h))
+      };
+      const d = Ul(u);
+      return d && await tt(d), !0;
+    }, le = () => e.runtime.api.rows.hasInsertSupport(), Oe = () => e.runtime.api.rows.hasDataMutationSupport(), ue = (t) => !t || typeof t != "object" ? !1 : "data" in t || "row" in t || "kind" in t || "state" in t || "sourceIndex" in t || "originalIndex" in t || "displayIndex" in t, ce = (t) => {
+      const n = t;
+      return n.rowId != null ? String(n.rowId) : n.id != null ? String(n.id) : null;
+    }, de = (t) => {
+      for (const n of e.rows) {
+        if (!n || typeof n != "object")
+          continue;
+        const a = n;
+        if ((a.rowId != null ? String(a.rowId) : a.rowKey != null ? String(a.rowKey) : null) === t && ue(a))
+          return a;
+      }
+      for (const n of e.rows) {
+        if (!n || typeof n != "object")
+          continue;
+        const a = n;
+        if (ue(a))
+          return a;
+      }
+      return null;
+    }, me = () => (se += 1, `datagrid-row-${Date.now()}-${se}`), ot = (t) => {
+      const n = J(t), a = me();
+      let u = !1;
+      return "id" in n && (n.id = a, u = !0), "rowId" in n && (n.rowId = a, u = !0), u || (n.id = a), n;
+    }, rt = (t) => {
+      const n = me(), a = {};
+      for (const [u, d] of Object.entries(t)) {
+        if (u === "id" || u === "rowId") {
+          a[u] = n;
+          continue;
+        }
+        a[u] = typeof d == "number" ? null : "";
+      }
+      return !("id" in a) && !("rowId" in a) && (a.id = n), a;
+    }, it = (t, n, a) => {
+      const u = me(), d = a === "clone" ? J(t) : Object.entries(t).reduce((S, [D, p]) => (S[D] = typeof p == "number" ? null : "", S), {});
+      ("id" in d || !("rowId" in d) && !("id" in d)) && (d.id = u), "rowId" in d && (d.rowId = u), "rowKey" in d && (d.rowKey = u);
+      const h = typeof n.state == "object" && n.state != null ? n.state : null;
+      return {
+        kind: n.kind === "group" ? "leaf" : n.kind ?? "leaf",
+        rowId: u,
+        rowKey: u,
+        state: {
+          ...h ?? {},
+          selected: !1,
+          group: !1,
+          pinned: "none",
+          expanded: !1
+        },
+        data: d,
+        row: J(d)
+      };
+    }, Nt = (t, n = null) => n && ue(n) ? it(t, n, "clone") : ot(t), at = (t, n = null) => n && ue(n) ? it(t, n, "blank") : rt(t), st = (t) => {
+      const a = (e.rowSelectionSnapshot.value?.selectedRows ?? []).map((h) => String(h)).filter((h) => h.length > 0 && Ae(h)?.kind !== "group");
+      if (a.length > 0)
+        return a;
+      const u = xe(), d = R.value.length - 1;
+      if (u && d >= 0) {
+        const h = Math.min(u.startColumn, u.endColumn), S = Math.max(u.startColumn, u.endColumn), D = Math.min(u.startRow, u.endRow), p = Math.max(u.startRow, u.endRow), P = t.length > 0 ? e.runtime.resolveBodyRowIndexById(t) : -1;
+        if (h === 0 && S === d && (P < 0 || P >= D && P <= p)) {
+          const $ = [];
+          for (let T = D; T <= p; T += 1) {
+            const E = e.runtime.getBodyRowAtIndex(T);
+            !E || E.kind === "group" || E.rowId == null || $.push(String(E.rowId));
+          }
+          if ($.length > 0)
+            return $;
+        }
+      }
+      return t.length > 0 ? [t] : [];
+    }, ut = () => {
+      const t = [], n = e.runtime.api.rows.getCount();
+      for (let a = 0; a < n; a += 1) {
+        const u = e.runtime.api.rows.get(a);
+        !u || u.kind === "group" || t.push(u.data);
+      }
+      return t;
+    }, $t = (t) => {
+      if (!Oe() || t.length === 0)
+        return !1;
+      const n = new Set(t), a = ut().filter((u) => {
+        const d = ce(u);
+        return d == null || !n.has(d);
+      });
+      return a.length === e.runtime.api.rows.getCount() ? !1 : (e.runtime.api.rows.replaceData(a), e.runtime.api.rowSelection.hasSupport() && (e.runtime.api.rowSelection.clearSelectedRows(), e.syncRowSelectionSnapshotFromRuntime?.()), !0);
+    }, we = (t, n) => {
+      if (!Oe() || t.length === 0 || !n)
+        return !1;
+      const a = ut(), u = new Set(t.map((D) => String(D)));
+      if (u.has(String(n)))
+        return !1;
+      const d = a.filter((D) => {
+        const p = ce(D);
+        return p != null && u.has(p);
+      });
+      if (d.length === 0)
+        return !1;
+      const h = a.filter((D) => {
+        const p = ce(D);
+        return p == null || !u.has(p);
+      }), S = h.findIndex((D) => ce(D) === n);
+      return S < 0 ? !1 : (e.runtime.api.rows.replaceData([
+        ...h.slice(0, S + 1),
+        ...d,
+        ...h.slice(S + 1)
+      ]), e.runtime.api.rowSelection.hasSupport() && (e.runtime.api.rowSelection.selectRows(t), e.syncRowSelectionSnapshotFromRuntime?.()), !0);
+    }, ct = () => z.value ? (z.value = null, !0) : !1, Ut = (t) => {
+      if (t.kind === "group")
+        return !1;
+      const n = z.value;
+      return n ? n.sourceRowIds.includes(String(t.rowId)) : !1;
+    };
+    let dt = () => !1, mt = () => {
+    }, wt = () => {
+    }, Fe = async (t, n) => !1;
+    const qt = (t, n) => {
+      if (n)
+        return n;
+      const a = In[t], u = oo[t];
+      return u ? `${a} (${u})` : a;
+    }, {
+      tableStageProps: De,
+      tableStageContext: ft,
+      copySelectedCells: Xt,
+      pasteSelectedCells: Yt,
+      cutSelectedCells: Ct,
+      clearSelectedCells: Jt,
+      captureHistorySnapshot: fe,
+      recordHistoryIntentTransaction: Zt
+    } = Bl({
+      mode: b,
+      rows: A,
+      sourceRows: A,
+      runtime: e.runtime,
+      rowVersion: o,
+      totalRuntimeRows: v,
+      visibleColumns: R,
+      rowRenderMode: m(() => e.renderMode),
+      rowHeightMode: I,
+      normalizedBaseRowHeight: x,
+      selectionSnapshot: e.selectionSnapshot,
+      selectionAnchor: e.selectionAnchor,
+      rowSelectionSnapshot: e.rowSelectionSnapshot,
+      rowHover: m(() => e.rowHover),
+      stripedRows: m(() => e.stripedRows),
+      showRowIndex: m(() => e.showRowIndex),
+      showRowSelection: m(() => e.rowSelection),
+      isRowInPendingClipboardCut: Ut,
+      syncSelectionSnapshotFromRuntime: e.syncSelectionSnapshotFromRuntime,
+      syncRowSelectionSnapshotFromRuntime: e.syncRowSelectionSnapshotFromRuntime,
+      clearExternalPendingClipboardOperation: ct,
+      firstColumnKey: N,
+      columnFilterTextByKey: s,
+      virtualization: m(() => e.virtualization),
+      toggleSortForColumn: Bt,
+      sortIndicator: pe,
+      setColumnFilterText: Ke,
+      columnMenuEnabled: m(() => e.columnMenu.enabled),
+      columnMenuMaxFilterValues: m(() => e.columnMenu.maxFilterValues),
+      resolveColumnMenuItems: Q,
+      resolveColumnMenuDisabledItems: Ge,
+      resolveColumnMenuDisabledReasons: Pe,
+      resolveColumnMenuLabels: ae,
+      resolveColumnMenuActionOptions: Le,
+      isColumnFilterActive: Be,
+      isColumnGrouped: Re,
+      resolveColumnGroupOrder: X,
+      resolveColumnMenuSortDirection: $e,
+      resolveColumnMenuSelectedTokens: _e,
+      applyColumnMenuSort: Ue,
+      applyColumnMenuPin: qe,
+      applyColumnMenuGroupBy: Xe,
+      applyColumnMenuFilter: Ye,
+      clearColumnMenuFilter: Ie,
+      applyRowHeightSettings: _t,
+      cloneRowData: J,
+      isCellEditable: e.isCellEditable,
+      isContextMenuVisible: () => dt(),
+      closeContextMenu: () => mt(),
+      openContextMenuFromCurrentCell: () => {
+        wt();
+      },
+      runRowIndexKeyboardAction: (t, n) => Fe(t, n)
+    }), {
+      contextMenu: B,
+      contextMenuRef: gt,
+      contextMenuStyle: Qt,
+      closeContextMenu: Y,
+      openContextMenu: Ee,
+      onContextMenuKeyDown: en
+    } = Wn();
+    dt = () => B.value.visible, mt = Y;
+    const tn = il({
+      isInteractionBlocked: () => !1,
+      isRangeMoveModifierActive: () => !1,
+      resolveSelectionRange: xe,
+      resolveCellCoordFromDataset: Wt,
+      applyCellSelection: (t) => {
+        e.runtime.api.selection.setSnapshot(et(t)), e.syncSelectionSnapshotFromRuntime();
+      },
+      resolveActiveCellCoord: Je,
+      setActiveCellCoord: (t) => {
+        e.runtime.api.selection.setSnapshot(et(t)), e.syncSelectionSnapshotFromRuntime();
+      },
+      cellCoordsEqual: (t, n) => t?.rowIndex === n?.rowIndex && t?.columnIndex === n?.columnIndex,
+      isMultiCellSelection: Ze,
+      isCoordInsideRange: Qe,
+      openContextMenu: Ee,
+      closeContextMenu: Y,
+      isColumnContextEnabled: (t) => e.cellMenu.enabled ? ht(e.cellMenu, t).length > 0 : !1,
+      isRowIndexContextEnabled: () => e.rowIndexMenu.enabled && e.showRowIndex
+    }), nn = al({
+      resolveCurrentCellCoord: Je,
+      resolveViewportElement: () => ne.value,
+      resolveRowAtIndex: (t) => e.runtime.getBodyRowAtIndex(t) ?? void 0,
+      resolveColumnAtIndex: (t) => R.value[t] ?? void 0,
+      resolveSelectionRange: xe,
+      isMultiCellSelection: (t) => Ze(t),
+      isCoordInsideRange: Qe,
+      openContextMenu: Ee,
+      isColumnContextEnabled: (t) => e.cellMenu.enabled && ht(e.cellMenu, t.key).length > 0
+    });
+    wt = () => {
+      nn.openContextMenuFromCurrentCell();
+    };
+    const ln = (t) => {
+      if (!e.rowIndexMenu.enabled || !e.showRowIndex || !ne.value)
+        return !1;
+      const n = String(t), a = `.datagrid-stage__row-index-cell[data-row-id="${Kl(n)}"]`, u = ne.value.querySelector(a);
+      if (!u)
+        return !1;
+      const d = u.getBoundingClientRect();
+      return Ee(
+        d.left + Math.max(10, Math.min(d.width / 2, Math.max(10, d.width - 10))),
+        d.bottom - 4,
+        {
+          zone: "row-index",
+          rowId: n
+        }
+      ), !0;
+    }, Ce = (t, n) => {
+      Zt({
+        intent: "edit",
+        label: n
+      }, t);
+    };
+    Fe = async (t, n) => {
+      const a = String(n);
+      if (t === "open-row-menu")
+        return ln(a);
+      const u = Ae(a);
+      if (!u || u.kind === "group")
+        return !1;
+      if (t === "insert-row-above") {
+        if (!le())
+          return !1;
+        const d = fe(), h = e.runtime.api.rows.insertDataBefore(
+          n,
+          [at(u.data, de(a))]
+        );
+        return h && Ce(d, "Insert row above"), h;
+      }
+      if (t === "insert-row-below") {
+        if (!le())
+          return !1;
+        const d = fe(), h = e.runtime.api.rows.insertDataAfter(
+          n,
+          [at(u.data, de(a))]
+        );
+        return h && Ce(d, "Insert row below"), h;
+      }
+      if (t === "copy-row")
+        return lt([u.data], "copy", [a]);
+      if (t === "cut-row")
+        return lt([u.data], "cut", [a]);
+      if (t === "paste-row") {
+        if (!le())
+          return !1;
+        const d = await Kt();
+        if (!d || d.length === 0)
+          return !1;
+        const h = fe(), S = z.value?.operation === "cut" ? z.value.sourceRowIds : [], D = de(
+          S[0] ?? a
+        ) ?? de(a), p = S.length > 0 ? we(S, a) : e.runtime.api.rows.insertDataAfter(
+          n,
+          d.map((P) => Nt(P, D))
+        );
+        return p && z.value?.operation === "cut" && (z.value = null), p && Ce(
+          h,
+          S.length > 0 ? S.length > 1 ? `Move ${S.length} rows` : "Move row" : d.length > 1 ? `Paste ${d.length} rows` : "Paste row"
+        ), p;
+      }
+      if (t === "delete-selected-rows") {
+        const d = st(a);
+        if (d.length === 0)
+          return !1;
+        const h = fe(), S = $t(d);
+        return S && Ce(h, d.length > 1 ? `Delete ${d.length} rows` : "Delete row"), S;
+      }
+      return !1;
+    };
+    const on = sl({
+      resolveContextMenuState: () => ({
+        zone: B.value.zone,
+        columnKey: B.value.columnKey,
+        rowId: B.value.rowId
+      }),
+      runHeaderContextAction: () => !1,
+      runRowIndexContextAction: Fe,
+      copySelection: Xt,
+      pasteSelection: Yt,
+      cutSelection: Ct,
+      clearCurrentSelection: Jt,
+      closeContextMenu: Y
+    }), ke = m(() => {
+      if (!B.value.visible)
+        return [];
+      const t = B.value.zone;
+      if (t === "cell" || t === "range") {
+        const n = B.value.columnKey ?? "";
+        if (!e.cellMenu.enabled || !n)
+          return [];
+        const a = ht(e.cellMenu, n), u = new Set(bl(e.cellMenu, n)), d = hl(e.cellMenu, n), h = Rl(e.cellMenu, n);
+        return a.flatMap((S, D) => {
+          const p = no[S] ?? [];
+          return p.flatMap((P) => {
+            const T = h[P];
+            if (T?.hidden)
+              return [];
+            const E = u.has(S) || T?.disabled === !0;
+            return [{
+              id: P,
+              label: T?.label ?? In[P],
+              disabled: E,
+              title: T?.disabledReason ?? d[S],
+              separatorBefore: D > 0 && P === p[0]
+            }];
+          });
+        });
+      }
+      if (t === "row-index") {
+        if (!e.rowIndexMenu.enabled)
+          return [];
+        const n = yl(e.rowIndexMenu), a = new Set(Sl(e.rowIndexMenu)), u = pl(e.rowIndexMenu), d = Ml(e.rowIndexMenu);
+        return n.flatMap((h, S) => {
+          const D = lo[h] ?? [];
+          return D.flatMap((p) => {
+            const $ = d[p === "insert-row-above" ? "insertAbove" : p === "insert-row-below" ? "insertBelow" : p === "copy-row" ? "copy" : p === "paste-row" ? "paste" : p === "delete-selected-rows" ? "deleteSelected" : "cut"];
+            if ($?.hidden)
+              return [];
+            let T = a.has(h) || $?.disabled === !0, E = $?.disabledReason ?? u[h];
+            return (p === "insert-row-above" || p === "insert-row-below" || p === "paste-row") && !le() && (T = !0, E = E ?? "Row insertion is not supported by the current row model"), (p === "cut-row" || p === "delete-selected-rows") && !Oe() && (T = !0, E = E ?? "Row deletion is not supported by the current row model"), p === "delete-selected-rows" && st(B.value.rowId ?? "").length === 0 && (T = !0, E = E ?? "No deletable rows are selected"), [{
+              id: p,
+              label: qt(p, $?.label),
+              disabled: T,
+              title: E,
+              separatorBefore: S > 0 && p === D[0]
+            }];
+          });
+        });
+      }
+      return [];
+    }), vt = (t) => {
+      tn.dispatchViewportContextMenu(t);
+    }, ge = () => {
+      ne.value?.querySelector(".grid-body-viewport")?.focus({ preventScroll: !0 });
+    }, rn = () => {
+      Dn(() => {
+        if (typeof window < "u") {
+          window.requestAnimationFrame(() => {
+            ge();
+          });
+          return;
+        }
+        ge();
+      });
+    }, O = async (t) => {
+      await on.runContextMenuAction(t) && (ge(), Y(), rn());
+    };
+    K(
+      () => B.value.visible,
+      (t, n, a) => {
+        if (!t || typeof window > "u")
+          return;
+        const u = (h) => {
+          const S = h.target;
+          S && gt.value?.contains(S) || Y();
+        }, d = () => {
+          Y();
+        };
+        window.addEventListener("mousedown", u, !0), window.addEventListener("blur", d), a(() => {
+          window.removeEventListener("mousedown", u, !0), window.removeEventListener("blur", d);
+        });
+      }
+    );
+    const an = m(() => ({
+      ...De.value,
+      columns: {
+        ...De.value.columns,
+        columnMenuEnabled: e.columnMenu.enabled,
+        columnMenuMaxFilterValues: e.columnMenu.maxFilterValues,
+        resolveColumnMenuItems: Q,
+        resolveColumnMenuDisabledItems: Ge,
+        resolveColumnMenuDisabledReasons: Pe,
+        resolveColumnMenuLabels: ae,
+        resolveColumnMenuActionOptions: Le,
+        isColumnFilterActive: Be,
+        isColumnGrouped: Re,
+        resolveColumnGroupOrder: X,
+        resolveColumnMenuSortDirection: $e,
+        resolveColumnMenuSelectedTokens: _e,
+        applyColumnMenuSort: Ue,
+        applyColumnMenuPin: qe,
+        applyColumnMenuGroupBy: Xe,
+        applyColumnMenuFilter: Ye,
+        clearColumnMenuFilter: Ie
+      },
+      rows: {
+        ...De.value.rows,
+        sourceRows: e.rows,
+        rowHover: e.rowHover,
+        stripedRows: e.stripedRows
+      }
+    })), sn = m(() => {
+      const t = [];
+      return e.columnLayout.enabled && t.push({
+        key: "column-layout",
+        component: _l,
+        props: {
+          isOpen: ze.value,
+          items: pt.value,
+          buttonLabel: e.columnLayout.buttonLabel,
+          active: !1,
+          onOpen: Mt,
+          onToggleVisibility: Ot,
+          onMoveUp: xt,
+          onMoveDown: At,
+          onApply: It,
+          onCancel: H
+        }
+      }), e.advancedFilter.enabled && t.push({
+        key: "advanced-filter",
+        component: Gl,
+        props: {
+          isOpen: Ft.value,
+          clauses: Dt.value,
+          columns: g.value,
+          appliedFilterSummaryItems: Se.value,
+          hasAnyFilters: We.value,
+          buttonLabel: e.advancedFilter.buttonLabel,
+          active: We.value,
+          onOpen: Et,
+          onAdd: kt,
+          onRemove: Ht,
+          onUpdateClause: V,
+          onApply: zt,
+          onCancel: Vt,
+          onResetAll: jt
+        }
+      }), e.aggregations.enabled && e.mode !== "pivot" && t.push({
+        key: "aggregations",
+        component: Pl,
+        props: {
+          isOpen: q.value,
+          basis: ie.value,
+          items: je.value,
+          buttonLabel: e.aggregations.buttonLabel,
+          active: L.value && (q.value || !!re.value?.columns.length),
+          disabled: !L.value,
+          disabledReason: L.value ? "" : "Aggregations require an active group-by model.",
+          onOpen: Gt,
+          onUpdateBasis: Ne,
+          onToggleColumn: ee,
+          onUpdateOp: te,
+          onClear: Pt,
+          onApply: Lt,
+          onCancel: Me
+        }
+      }), [...t, ...e.toolbarModules];
+    });
+    return () => k("div", {
+      class: "datagrid-app-layout"
+    }, [
+      k(dl, {
+        modules: sn.value
+      }),
+      k("div", {
+        class: "datagrid-app-workspace"
+      }, [
+        k("div", {
+          class: "datagrid-app-stage",
+          ref: ne
+        }, [
+          e.viewMode === "gantt" ? k(Ll, {
+            stageContext: ft,
+            runtime: e.runtime,
+            gantt: e.gantt,
+            baseRowHeight: x.value,
+            rowVersion: o.value
+          }) : k(cl, {
+            ...an.value,
+            stageContext: ft,
+            onViewportContextMenu: vt
+          }),
+          B.value.visible && ke.value.length > 0 ? k("div", {
+            ref: gt,
+            class: "datagrid-context-menu",
+            style: Qt.value,
+            role: "menu",
+            tabindex: -1,
+            onKeydown: (t) => {
+              en(t, {
+                onEscape: () => {
+                  ge();
+                }
+              });
+            }
+          }, ke.value.flatMap((t) => {
+            const n = [];
+            return t.separatorBefore && n.push(k("div", {
+              class: "datagrid-context-menu__separator",
+              "aria-hidden": "true"
+            })), n.push(k("button", {
+              type: "button",
+              class: "datagrid-context-menu__item",
+              "data-datagrid-menu-action": t.id,
+              disabled: t.disabled,
+              title: t.title,
+              onClick: () => {
+                O(t.id);
+              }
+            }, t.label)), n;
+          })) : null
+        ]),
+        e.inspectorPanel ? k("aside", {
+          class: "datagrid-app-inspector-shell"
+        }, [
+          k(e.inspectorPanel.component, {
+            ...e.inspectorPanel.props ?? {}
+          })
+        ]) : null
+      ])
+    ]);
+  }
+}), wn = /* @__PURE__ */ new WeakMap(), xn = /* @__PURE__ */ new WeakMap();
+function ro(e) {
+  if (!e)
+    return;
+  const o = wn.get(e);
+  if (o)
+    return o;
+  const r = e.initialTreeData?.expandedByDefault ?? !1;
+  if (e.initialTreeData?.expandedByDefault === r)
+    return wn.set(e, e), e;
+  const l = {
+    ...e
+  };
+  return e.initialTreeData && (l.initialTreeData = {
+    ...e.initialTreeData,
+    expandedByDefault: r
+  }), wn.set(e, l), l;
+}
+function io(e) {
+  return !e || e.length === 0 ? [] : e.map((o) => ({ ...o }));
+}
+function ao(e) {
+  return !e || e.length === 0 ? [] : e.map((o) => ({ ...o }));
+}
+function so(e) {
+  return !e || e.length === 0 ? [] : e.map(({ formula: o, ...r }) => ({ ...r }));
+}
+function uo(e) {
+  return !e || e.length === 0 ? [] : e.flatMap((o) => {
+    const r = typeof o.formula == "string" ? o.formula.trim() : "";
+    return r ? [{
+      name: o.key,
+      formula: r
+    }] : [];
+  });
+}
+function co(e, o) {
+  const r = /* @__PURE__ */ new Map();
+  for (const l of e)
+    r.set(l.name, { ...l });
+  for (const l of io(o))
+    r.set(l.name, l);
+  return Array.from(r.values());
+}
+function po(e) {
+  return so(e);
+}
+function Mo(e) {
+  const o = ro(e.clientRowModelOptions), r = e.enterpriseClientRowModelOptions, l = uo(e.columns), s = e.formulas !== void 0, i = e.computedFields !== void 0, w = e.formulaFunctions !== void 0, C = l.length > 0, b = s || C ? co(l, e.formulas) : void 0, A = i ? ao(e.computedFields) : void 0, v = w ? e.formulaFunctions ?? {} : void 0, R = !!(C || s || i || w);
+  if (!o && !R)
+    return r ? {
+      ...r
+    } : void 0;
+  if (!R) {
+    if (o && !r)
+      return o;
+    if (!o && r)
+      return r;
+    if (o && r) {
+      let y = xn.get(o);
+      y || (y = /* @__PURE__ */ new WeakMap(), xn.set(o, y));
+      const g = y.get(r);
+      if (g)
+        return g;
+      const f = {
+        ...o,
+        ...r
+      };
+      return y.set(
+        r,
+        f
+      ), f;
+    }
+  }
+  return {
+    ...o ?? {},
+    ...i ? { initialComputedFields: A } : {},
+    ...s || C ? { initialFormulaFields: b } : {},
+    ...w ? { initialFormulaFunctionRegistry: v } : {},
+    ...r?.computeMode ? { computeMode: r.computeMode } : {},
+    ...r?.workerPatchDispatchThreshold !== void 0 ? { workerPatchDispatchThreshold: r.workerPatchDispatchThreshold } : {},
+    ...r?.formulaColumnCacheMaxColumns !== void 0 ? { formulaColumnCacheMaxColumns: r.formulaColumnCacheMaxColumns } : {}
+  };
+}
+function An() {
+  const e = globalThis.performance;
+  return e && typeof e.now == "function" ? e.now() : Date.now();
+}
+const mo = (e, o) => {
+  const r = An();
+  return {
+    result: o(),
+    duration: Math.max(0, An() - r)
+  };
+};
+function On(e) {
+  return {
+    projectionStageTimer: mo,
+    ...e ?? {}
+  };
+}
+function Io(e) {
+  const o = W(0), r = un(), l = _n(
+    e.rowModel.value ? null : un({
+      rows: e.rows.value,
+      ...On(e.clientRowModelOptions.value)
+    })
+  ), s = (C) => {
+    !C || C === e.rowModel.value || "dispose" in C && typeof C.dispose == "function" && C.dispose();
+  }, i = () => {
+    e.rowModel.value || (s(l.value), l.value = un({
+      rows: e.rows.value,
+      ...On(e.clientRowModelOptions.value)
+    }), o.value += 1, e.onOwnedRowModelRecreated?.());
+  }, w = m(() => e.rowModel.value ?? l.value ?? r);
+  return K(
+    e.rows,
+    (C) => {
+      l.value && l.value.setRows(C);
+    },
+    { deep: !1 }
+  ), K(
+    e.clientRowModelOptions,
+    () => {
+      i();
+    },
+    { deep: !0 }
+  ), K(
+    e.rowModel,
+    (C) => {
+      if (C) {
+        s(l.value), l.value = null, o.value += 1;
+        return;
+      }
+      l.value || i();
+    }
+  ), En(() => {
+    s(l.value), s(r);
+  }), {
+    dataGridInstanceKey: o,
+    resolvedRowModel: w,
+    disposeOwnedRowModel: s
+  };
+}
+export {
+  So as D,
+  dl as a,
+  Il as b,
+  Bl as c,
+  ho as d,
+  Ro as e,
+  yo as f,
+  po as g,
+  Mo as r,
+  Io as u
+};