@affino/datagrid-vue-app 0.1.13 → 0.1.15

package/dist/chunks/useDataGridAppRowModel-Bxzexir6.js

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