@affino/datagrid-vue-app 0.1.21 → 0.1.23

package/dist/chunks/useDataGridAppRowModel-qRa5om5I.js

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