@affino/datagrid-vue-app 0.1.18 → 0.1.20

package/dist/chunks/useDataGridAppRowModel-Cq1nWBYl.js

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