@affino/datagrid-vue-app 0.1.18 → 0.1.19

package/dist/chunks/useDataGridAppRowModel-pcd72QS1.js

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