@affino/datagrid-vue-app 0.1.44 → 0.1.45

package/dist/chunks/useDataGridAppRowModel-BoU8RlUc.js

@@ -0,0 +1,4742 @@
+import { defineComponent as kn, h as B, inject as wr, ref as q, computed as w, watch as te, nextTick as et, openBlock as Ht, createElementBlock as An, Fragment as Gl, createElementVNode as oe, mergeProps as Ll, unref as m, toDisplayString as Qe, createBlock as gr, Teleport as vr, renderList as hr, normalizeClass as br, createCommentVNode as yr, onMounted as Rr, onBeforeUnmount as $l, shallowRef as Ml, defineAsyncComponent as Pl, markRaw as Cr, toRaw as pr, onUnmounted as Sr } from "vue";
+import { resolveDataGridCellClickAction as Ir, invokeDataGridCellInteraction as xr, toggleDataGridCellValue as Mr, buildDataGridCellRenderModel as Fr, buildDataGridAdvancedFilterExpressionFromLegacyFilters as Ar, useDataGridContextMenu as Dr, cloneDataGridFilterSnapshot as Or, createClientRowModel as Rl } from "@affino/datagrid-vue";
+import { useDataGridAppIntentHistory as _r, createDataGridAppRowHeightMetrics as kr, useDataGridAppViewport as Er, useDataGridAppRowSizing as Pr, useDataGridAppCellSelection as Tr, useDataGridAppRowPresentation as zr, useDataGridAppClipboard as Hr, useDataGridAppActiveCellViewport as Vr, useDataGridAppInlineEditing as Br, useDataGridAppInteractionController as jr, useDataGridAppHeaderResize as Gr, useDataGridAppRuntimeSync as Lr, useDataGridAppViewportLifecycle as $r, useDataGridAppColumnLayoutPanel as Kr } from "@affino/datagrid-vue/app";
+import { useDataGridViewportContextMenuRouter as Nr, useDataGridContextMenuAnchor as Wr, useDataGridContextMenuActionRouter as Ur } from "@affino/datagrid-vue/advanced";
+import { c as qr, q as Yr, D as Kl, a as Nl, s as Jr } from "./DataGridGanttStageEntry-CKjSVRMy.js";
+import { usePopoverController as Xr, useFloatingPopover as Zr } from "@affino/popover-vue";
+import { d as Qr, r as eo } from "./dataGridOverlayThemeVars-vzY74EIz.js";
+import { u as to } from "./useDataGridDraggableOverlaySurface-BgkSR_nl.js";
+import { a as no } from "./dataGridAdvancedFilter-xnME5bRa.js";
+const Wl = kn({
+  name: "DataGridModuleHost",
+  props: {
+    modules: {
+      type: Array,
+      default: () => []
+    },
+    variant: {
+      type: String,
+      default: "standalone"
+    }
+  },
+  setup(e) {
+    return () => e.modules.length === 0 ? null : B("div", {
+      class: [
+        "datagrid-app-toolbar",
+        e.variant === "integrated" ? "datagrid-app-toolbar--integrated" : null
+      ]
+    }, [
+      B("div", { class: "datagrid-app-toolbar__group" }, e.modules.map((l) => B(l.component, {
+        key: l.key,
+        ...l.props ?? {}
+      })))
+    ]);
+  }
+}), Ul = kn({
+  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 () => B("button", {
+      type: "button",
+      class: "datagrid-app-toolbar__button",
+      "data-datagrid-toolbar-action": e.action,
+      disabled: e.disabled,
+      onClick: () => {
+        e.onTrigger();
+      }
+    }, e.label);
+  }
+}), or = "Columns", Te = Object.freeze({
+  buttonLabel: or,
+  eyebrow: "Column layout",
+  title: "Order and visibility",
+  close: "Close",
+  cancel: "Cancel",
+  apply: "Apply",
+  moveUp: "Move up",
+  moveDown: "Move down"
+});
+function Pe(e, l) {
+  return typeof e == "string" && e.trim().length > 0 ? e.trim() : l;
+}
+function Cl(e, l) {
+  const a = Pe(l, Pe(e?.buttonLabel, or));
+  return Object.freeze({
+    buttonLabel: a,
+    eyebrow: Pe(e?.eyebrow, Te.eyebrow),
+    title: Pe(e?.title, Te.title),
+    close: Pe(e?.close, Te.close),
+    cancel: Pe(e?.cancel, Te.cancel),
+    apply: Pe(e?.apply, Te.apply),
+    moveUp: Pe(e?.moveUp, Te.moveUp),
+    moveDown: Pe(e?.moveDown, Te.moveDown)
+  });
+}
+function La(e) {
+  if (typeof e == "boolean") {
+    const a = Cl(void 0);
+    return {
+      enabled: e,
+      buttonLabel: a.buttonLabel,
+      labels: a
+    };
+  }
+  if (!e) {
+    const a = Cl(void 0);
+    return {
+      enabled: !1,
+      buttonLabel: a.buttonLabel,
+      labels: a
+    };
+  }
+  const l = Cl(e.labels, e.buttonLabel);
+  return {
+    enabled: e.enabled ?? !0,
+    buttonLabel: l.buttonLabel,
+    labels: l
+  };
+}
+const lo = ["data-datagrid-overlay-dragging"], ro = { class: "datagrid-column-layout__header" }, oo = { class: "datagrid-column-layout__eyebrow" }, ao = { class: "datagrid-column-layout__title" }, io = { class: "datagrid-column-layout__list" }, so = ["onDragstart", "onDragover", "onDrop"], uo = { class: "datagrid-column-layout__visibility" }, co = /* @__PURE__ */ oe("span", {
+  class: "datagrid-column-layout__drag-handle",
+  "aria-hidden": "true"
+}, "::", -1), mo = ["name", "checked", "onChange"], fo = { class: "datagrid-column-layout__label" }, wo = { class: "datagrid-column-layout__move-actions" }, go = ["disabled", "aria-label", "title", "onClick"], vo = ["disabled", "aria-label", "title", "onClick"], ho = { class: "datagrid-column-layout__footer" }, bo = /* @__PURE__ */ kn({
+  __name: "DataGridColumnLayoutPopover",
+  props: {
+    isOpen: { type: Boolean },
+    items: {},
+    buttonLabel: {},
+    labels: { default: () => Te },
+    active: { type: Boolean, default: !1 }
+  },
+  emits: ["open", "toggle-visibility", "move-up", "move-down", "move-to-position", "apply", "cancel"],
+  setup(e, { emit: l }) {
+    const a = e, r = l, u = wr(Qr, q(null)), i = q({}), g = Xr(
+      {
+        id: "column-layout",
+        role: "dialog",
+        closeOnEscape: !0,
+        closeOnInteractOutside: !0
+      },
+      {
+        onOpen: () => {
+          a.isOpen || r("open"), Y();
+        },
+        onClose: () => {
+          a.isOpen && r("cancel");
+        }
+      }
+    ), h = Zr(g, {
+      placement: "bottom",
+      align: "start",
+      gutter: 10,
+      viewportPadding: 12,
+      zIndex: 180,
+      lockScroll: !1,
+      returnFocus: !0
+    }), R = to({
+      surfaceId: "column-layout",
+      rootElementRef: u,
+      floating: h
+    }), E = w(() => g.getTriggerProps({ role: "dialog" })), O = w(() => g.getContentProps({ role: "dialog", tabIndex: -1 })), G = w(() => g.state.value.open), I = w(() => h.teleportTarget.value), b = w(() => a.labels ?? Te), F = w(() => typeof a.buttonLabel == "string" && a.buttonLabel.trim().length > 0 ? a.buttonLabel.trim() : b.value.buttonLabel), A = q(null), C = q(null), M = q(null);
+    te(
+      () => a.isOpen,
+      async (T) => {
+        if (T) {
+          Y(), g.state.value.open || g.open("programmatic"), await et(), h.contentRef.value?.querySelector('input[type="checkbox"]')?.focus({ preventScroll: !0 }), await h.updatePosition();
+          return;
+        }
+        g.state.value.open && g.close("programmatic");
+      },
+      { immediate: !0 }
+    ), te(u, () => {
+      g.state.value.open && Y();
+    }), te(
+      () => a.items.length,
+      async () => {
+        g.state.value.open && (await et(), await h.updatePosition());
+      }
+    );
+    function Y() {
+      i.value = eo(u.value);
+    }
+    function ne(T, z) {
+      r("toggle-visibility", { key: T, visible: z });
+    }
+    function j(T) {
+      const _ = (T.currentTarget instanceof HTMLElement ? T.currentTarget : null)?.getBoundingClientRect();
+      return !_ || _.height <= 0 ? "after" : T.clientY < _.top + _.height / 2 ? "before" : "after";
+    }
+    function Me(T, z) {
+      A.value = z, C.value = null, M.value = null, T.dataTransfer && (T.dataTransfer.effectAllowed = "move", T.dataTransfer.setData("text/plain", z));
+    }
+    function ft(T, z) {
+      if (!A.value || A.value === z) {
+        C.value = null, M.value = null;
+        return;
+      }
+      T.preventDefault(), T.dataTransfer && (T.dataTransfer.dropEffect = "move"), C.value = z, M.value = j(T);
+    }
+    function wt(T, z) {
+      if (!A.value || A.value === z) {
+        We();
+        return;
+      }
+      T.preventDefault(), r("move-to-position", {
+        key: A.value,
+        targetKey: z,
+        placement: j(T)
+      }), We();
+    }
+    function We() {
+      A.value = null, C.value = null, M.value = null;
+    }
+    return (T, z) => (Ht(), An(Gl, null, [
+      oe("button", Ll({
+        ref: m(h).triggerRef,
+        type: "button",
+        class: ["datagrid-app-toolbar__button", { "datagrid-app-toolbar__button--active": T.active }],
+        "data-datagrid-toolbar-action": "column-layout",
+        style: i.value
+      }, E.value), Qe(F.value), 17),
+      (Ht(), gr(vr, { to: I.value }, [
+        G.value ? (Ht(), An("section", Ll({
+          key: 0,
+          ref: m(h).contentRef,
+          class: "datagrid-column-layout",
+          "data-datagrid-overlay-surface": "true",
+          "data-datagrid-overlay-surface-id": "column-layout",
+          "data-datagrid-overlay-dragging": m(R).dragging.value ? "true" : "false",
+          style: [m(R).surfaceStyle.value, i.value]
+        }, O.value), [
+          oe("header", ro, [
+            oe("div", {
+              class: "datagrid-overlay-drag-handle",
+              "data-datagrid-overlay-drag-handle": "true",
+              onPointerdown: z[0] || (z[0] = //@ts-ignore
+              (..._) => m(R).handlePointerDown && m(R).handlePointerDown(..._))
+            }, [
+              oe("div", oo, Qe(b.value.eyebrow), 1),
+              oe("h3", ao, Qe(b.value.title), 1)
+            ], 32),
+            oe("button", {
+              type: "button",
+              class: "datagrid-column-layout__ghost",
+              onClick: z[1] || (z[1] = (_) => r("cancel"))
+            }, Qe(b.value.close), 1)
+          ]),
+          oe("div", io, [
+            (Ht(!0), An(Gl, null, hr(T.items, (_) => (Ht(), An("div", {
+              key: _.key,
+              class: br(["datagrid-column-layout__row", {
+                "datagrid-column-layout__row--drag-source": A.value === _.key,
+                "datagrid-column-layout__row--drop-before": C.value === _.key && M.value === "before",
+                "datagrid-column-layout__row--drop-after": C.value === _.key && M.value === "after"
+              }]),
+              draggable: !0,
+              onDragstart: (le) => Me(le, _.key),
+              onDragover: (le) => ft(le, _.key),
+              onDrop: (le) => wt(le, _.key),
+              onDragend: We
+            }, [
+              oe("label", uo, [
+                co,
+                oe("input", {
+                  name: `datagrid-column-layout-visible-${_.key}`,
+                  type: "checkbox",
+                  checked: _.visible,
+                  onChange: (le) => ne(_.key, le.target.checked)
+                }, null, 40, mo),
+                oe("span", fo, Qe(_.label), 1)
+              ]),
+              oe("div", wo, [
+                oe("button", {
+                  type: "button",
+                  class: "datagrid-column-layout__icon-button",
+                  disabled: !_.canMoveUp,
+                  "aria-label": `${b.value.moveUp}: ${_.label}`,
+                  title: `${b.value.moveUp}: ${_.label}`,
+                  onClick: (le) => r("move-up", _.key)
+                }, " ↑ ", 8, go),
+                oe("button", {
+                  type: "button",
+                  class: "datagrid-column-layout__icon-button",
+                  disabled: !_.canMoveDown,
+                  "aria-label": `${b.value.moveDown}: ${_.label}`,
+                  title: `${b.value.moveDown}: ${_.label}`,
+                  onClick: (le) => r("move-down", _.key)
+                }, " ↓ ", 8, vo)
+              ])
+            ], 42, so))), 128))
+          ]),
+          oe("footer", ho, [
+            oe("button", {
+              type: "button",
+              class: "datagrid-column-layout__secondary",
+              onClick: z[2] || (z[2] = (_) => r("cancel"))
+            }, Qe(b.value.cancel), 1),
+            oe("button", {
+              type: "button",
+              class: "datagrid-column-layout__primary",
+              onClick: z[3] || (z[3] = (_) => r("apply"))
+            }, Qe(b.value.apply), 1)
+          ])
+        ], 16, lo)) : yr("", !0)
+      ], 8, ["to"]))
+    ], 64));
+  }
+}), ze = ["sort", "group", "pin", "filter"], yo = ["button", "contextmenu", "button+contextmenu"], ar = [
+  "sortAsc",
+  "sortDesc",
+  "clearSort",
+  "toggleGroup",
+  "pinMenu",
+  "pinLeft",
+  "pinRight",
+  "unpin",
+  "clearFilter",
+  "addCurrentSelectionToFilter",
+  "selectAllValues",
+  "clearAllValues",
+  "applyFilter",
+  "cancelFilter"
+], pl = 120, Fl = "button+contextmenu";
+function Tl(e) {
+  const l = new Set(ze), a = Array.isArray(e) ? e : ze, r = [];
+  for (const u of a)
+    !l.has(u) || r.includes(u) || r.push(u);
+  return r.length > 0 ? r : [...ze];
+}
+function Al(e) {
+  if (!Array.isArray(e))
+    return [];
+  const l = new Set(ze), a = [];
+  for (const r of e)
+    !l.has(r) || a.includes(r) || a.push(r);
+  return a;
+}
+function ir(e) {
+  if (!e)
+    return Object.freeze({});
+  const l = Object.entries(e).filter(([a, r]) => ze.includes(a) && typeof r == "string").map(([a, r]) => [a, r.trim()]).filter(([, a]) => a.length > 0);
+  return Object.freeze(Object.fromEntries(l));
+}
+function sr(e) {
+  if (!e)
+    return Object.freeze({});
+  const l = Object.entries(e).filter(([a, r]) => ze.includes(a) && typeof r == "string").map(([a, r]) => [a, r.trim()]).filter(([, a]) => a.length > 0);
+  return Object.freeze(Object.fromEntries(l));
+}
+function Ro(e) {
+  return yo.includes(e) ? e : Fl;
+}
+function Co(e) {
+  if (e === "start" || e === "end")
+    return !0;
+  if (!e.includes(":"))
+    return !1;
+  const [l, a] = e.split(":");
+  return (l === "before" || l === "after") && ze.includes(a);
+}
+function zl(e) {
+  if (!Array.isArray(e))
+    return Object.freeze([]);
+  const l = [], a = /* @__PURE__ */ new Set();
+  for (const r of e) {
+    const u = typeof r?.key == "string" ? r.key.trim() : "", i = typeof r?.label == "string" ? r.label.trim() : "";
+    if (u.length === 0 || i.length === 0 || a.has(u))
+      continue;
+    a.add(u);
+    const g = typeof r.placement == "string" && Co(r.placement) ? r.placement : void 0, h = {
+      key: u,
+      label: i,
+      ...g ? { placement: g } : {},
+      ...r.hidden === !0 ? { hidden: !0 } : {},
+      ...r.disabled === !0 ? { disabled: !0 } : {},
+      ...typeof r.disabledReason == "string" && r.disabledReason.trim().length > 0 ? { disabledReason: r.disabledReason.trim() } : {}
+    };
+    if (r.kind === "submenu") {
+      const R = zl(r.items);
+      if (R.length === 0)
+        continue;
+      l.push(Object.freeze({
+        ...h,
+        kind: "submenu",
+        items: R
+      }));
+      continue;
+    }
+    l.push(Object.freeze({
+      ...h,
+      ...typeof r.onSelect == "function" ? { onSelect: r.onSelect } : {}
+    }));
+  }
+  return Object.freeze(l);
+}
+function ur(e) {
+  if (!e)
+    return Object.freeze({});
+  const l = Object.entries(e).filter(([a, r]) => ar.includes(a) && !!r).map(([a, r]) => {
+    const u = r, i = {
+      ...u.hidden === !0 ? { hidden: !0 } : {},
+      ...u.disabled === !0 ? { disabled: !0 } : {},
+      ...typeof u.disabledReason == "string" && u.disabledReason.trim().length > 0 ? { disabledReason: u.disabledReason.trim() } : {},
+      ...typeof u.label == "string" && u.label.trim().length > 0 ? { label: u.label.trim() } : {}
+    };
+    return [a, Object.freeze(i)];
+  }).filter(([, a]) => Object.keys(a).length > 0);
+  return Object.freeze(Object.fromEntries(l));
+}
+function po(e) {
+  if (!e)
+    return {};
+  const l = Object.entries(e).filter(([a]) => a.trim().length > 0).map(([a, r]) => {
+    const u = r?.items ? Tl(r.items) : void 0, i = Al(r?.hide), g = Al(r?.disabled), h = sr(r?.disabledReasons), R = ir(r?.labels), E = ur(r?.actions), O = zl(r?.customItems);
+    return [
+      a,
+      {
+        ...u ? { items: u } : {},
+        ...i.length > 0 ? { hide: i } : {},
+        ...g.length > 0 ? { disabled: g } : {},
+        ...Object.keys(h).length > 0 ? { disabledReasons: h } : {},
+        ...Object.keys(R).length > 0 ? { labels: R } : {},
+        ...Object.keys(E).length > 0 ? { actions: E } : {},
+        ...O.length > 0 ? { customItems: O } : {}
+      }
+    ];
+  });
+  return Object.fromEntries(l);
+}
+function $a(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    trigger: Fl,
+    maxFilterValues: pl,
+    items: [...ze],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    customItems: Object.freeze([]),
+    columns: {}
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    trigger: Ro(e.trigger),
+    maxFilterValues: Number.isFinite(e.maxFilterValues) ? Math.max(20, Math.trunc(e.maxFilterValues)) : pl,
+    items: Tl(e.items),
+    disabled: Al(e.disabled),
+    disabledReasons: sr(e.disabledReasons),
+    labels: ir(e.labels),
+    actions: ur(e.actions),
+    customItems: zl(e.customItems),
+    columns: po(e.columns)
+  } : {
+    enabled: !1,
+    trigger: Fl,
+    maxFilterValues: pl,
+    items: [...ze],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    customItems: Object.freeze([]),
+    columns: {}
+  };
+}
+function dr(e, l) {
+  const a = e.columns[l], r = a?.items ? Tl(a.items) : e.items, u = new Set(a?.hide ?? []), i = r.filter((g) => !u.has(g));
+  return i.length > 0 ? i : [];
+}
+function So(e, l) {
+  const a = dr(e, l), r = new Set(e.columns[l]?.disabled ?? []), u = new Set(e.disabled);
+  return a.filter((i) => u.has(i) || r.has(i));
+}
+function Io(e, l) {
+  return Object.freeze({
+    ...e.labels,
+    ...e.columns[l]?.labels ?? {}
+  });
+}
+function xo(e, l) {
+  return Object.freeze({
+    ...e.disabledReasons,
+    ...e.columns[l]?.disabledReasons ?? {}
+  });
+}
+function Mo(e, l) {
+  const a = e.columns[l]?.actions ?? {}, r = ar.map((u) => {
+    const i = {
+      ...e.actions[u] ?? {},
+      ...a[u] ?? {}
+    };
+    return [u, Object.freeze(i)];
+  }).filter(([, u]) => Object.keys(u).length > 0);
+  return Object.freeze(Object.fromEntries(r));
+}
+function Fo(e, l) {
+  const a = /* @__PURE__ */ new Map();
+  for (const r of e.customItems)
+    a.set(r.key, r);
+  for (const r of e.columns[l]?.customItems ?? [])
+    a.set(r.key, r);
+  return Object.freeze(Array.from(a.values()));
+}
+const fe = ["clipboard", "pasteSpecial", "edit"], Hl = ["cut", "copy", "paste", "pasteValues", "clear"], dt = ["insert", "clipboard", "selection"], cr = [
+  "insertAbove",
+  "insertBelow",
+  "cut",
+  "copy",
+  "paste",
+  "deleteSelected"
+];
+function En(e, l) {
+  const a = new Set(l), r = Array.isArray(e) ? e : l, u = [];
+  for (const i of r)
+    !a.has(i) || u.includes(i) || u.push(i);
+  return u.length > 0 ? u : [...l];
+}
+function _n(e, l) {
+  if (!Array.isArray(e))
+    return [];
+  const a = new Set(l), r = [];
+  for (const u of e)
+    !a.has(u) || r.includes(u) || r.push(u);
+  return r;
+}
+function mt(e, l) {
+  if (!e)
+    return Object.freeze({});
+  const a = Object.entries(e).filter((r) => l.includes(r[0]) && typeof r[1] == "string").map(([r, u]) => [r, u.trim()]).filter(([, r]) => r.length > 0);
+  return Object.freeze(Object.fromEntries(a));
+}
+function Vl(e, l) {
+  if (!e)
+    return Object.freeze({});
+  const a = Object.entries(e).filter(([r, u]) => l.includes(r) && !!u).map(([r, u]) => {
+    const i = u, g = {
+      ...i.hidden === !0 ? { hidden: !0 } : {},
+      ...i.disabled === !0 ? { disabled: !0 } : {},
+      ...typeof i.disabledReason == "string" && i.disabledReason.trim().length > 0 ? { disabledReason: i.disabledReason.trim() } : {},
+      ...typeof i.label == "string" && i.label.trim().length > 0 ? { label: i.label.trim() } : {}
+    };
+    return [r, Object.freeze(g)];
+  }).filter(([, r]) => Object.keys(r).length > 0);
+  return Object.freeze(Object.fromEntries(a));
+}
+function Ao(e) {
+  if (e === "start" || e === "end")
+    return !0;
+  if (!e.includes(":"))
+    return !1;
+  const [l, a] = e.split(":");
+  return (l === "before" || l === "after") && fe.includes(a);
+}
+function Bl(e) {
+  if (!Array.isArray(e))
+    return Object.freeze([]);
+  const l = [], a = /* @__PURE__ */ new Set();
+  for (const r of e) {
+    const u = typeof r?.key == "string" ? r.key.trim() : "", i = typeof r?.label == "string" ? r.label.trim() : "";
+    if (u.length === 0 || i.length === 0 || a.has(u))
+      continue;
+    a.add(u);
+    const g = typeof r.placement == "string" && Ao(r.placement) ? r.placement : void 0, h = {
+      key: u,
+      label: i,
+      ...g ? { placement: g } : {},
+      ...r.hidden === !0 ? { hidden: !0 } : {},
+      ...r.disabled === !0 ? { disabled: !0 } : {},
+      ...typeof r.disabledReason == "string" && r.disabledReason.trim().length > 0 ? { disabledReason: r.disabledReason.trim() } : {}
+    };
+    if (r.kind === "submenu") {
+      const R = Bl(r.items);
+      if (R.length === 0)
+        continue;
+      l.push(Object.freeze({
+        ...h,
+        kind: "submenu",
+        items: R
+      }));
+      continue;
+    }
+    l.push(Object.freeze({
+      ...h,
+      ...typeof r.onSelect == "function" ? { onSelect: r.onSelect } : {}
+    }));
+  }
+  return Object.freeze(l);
+}
+function Do(e) {
+  if (!e)
+    return {};
+  const l = Object.entries(e).filter(([a]) => a.trim().length > 0).map(([a, r]) => {
+    const u = r?.items ? En(r.items, fe) : void 0, i = _n(r?.hide, fe), g = _n(r?.disabled, fe), h = mt(r?.disabledReasons, fe), R = mt(r?.labels, fe), E = Vl(r?.actions, Hl), O = Bl(r?.customItems);
+    return [
+      a,
+      {
+        ...u ? { items: u } : {},
+        ...i.length > 0 ? { hide: i } : {},
+        ...g.length > 0 ? { disabled: g } : {},
+        ...Object.keys(h).length > 0 ? { disabledReasons: h } : {},
+        ...Object.keys(R).length > 0 ? { labels: R } : {},
+        ...Object.keys(E).length > 0 ? { actions: E } : {},
+        ...O.length > 0 ? { customItems: O } : {}
+      }
+    ];
+  });
+  return Object.freeze(Object.fromEntries(l));
+}
+function Ka(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    items: [...fe],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    customItems: Object.freeze([]),
+    columns: {}
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    items: En(e.items, fe),
+    disabled: _n(e.disabled, fe),
+    disabledReasons: mt(e.disabledReasons, fe),
+    labels: mt(e.labels, fe),
+    actions: Vl(e.actions, Hl),
+    customItems: Bl(e.customItems),
+    columns: Do(e.columns)
+  } : {
+    enabled: !1,
+    items: [...fe],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({}),
+    customItems: Object.freeze([]),
+    columns: {}
+  };
+}
+function On(e, l) {
+  const a = e.columns[l], r = a?.items ? En(a.items, fe) : e.items, u = new Set(a?.hide ?? []), i = r.filter((g) => !u.has(g));
+  return i.length > 0 ? i : [];
+}
+function Oo(e, l) {
+  const a = On(e, l), r = new Set(e.columns[l]?.disabled ?? []), u = new Set(e.disabled);
+  return a.filter((i) => u.has(i) || r.has(i));
+}
+function _o(e, l) {
+  return Object.freeze({
+    ...e.labels,
+    ...e.columns[l]?.labels ?? {}
+  });
+}
+function ko(e, l) {
+  return Object.freeze({
+    ...e.disabledReasons,
+    ...e.columns[l]?.disabledReasons ?? {}
+  });
+}
+function Eo(e, l) {
+  const a = e.columns[l]?.actions ?? {}, r = Hl.map((u) => {
+    const i = {
+      ...e.actions[u] ?? {},
+      ...a[u] ?? {}
+    };
+    return [u, Object.freeze(i)];
+  }).filter(([, u]) => Object.keys(u).length > 0);
+  return Object.freeze(Object.fromEntries(r));
+}
+function Po(e, l) {
+  const a = /* @__PURE__ */ new Map();
+  for (const r of e.customItems)
+    a.set(r.key, r);
+  for (const r of e.columns[l]?.customItems ?? [])
+    a.set(r.key, r);
+  return Object.freeze(Array.from(a.values()));
+}
+function Na(e) {
+  return typeof e == "boolean" ? {
+    enabled: e,
+    items: [...dt],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({})
+  } : e ? {
+    enabled: e.enabled ?? !0,
+    items: En(e.items, dt),
+    disabled: _n(e.disabled, dt),
+    disabledReasons: mt(e.disabledReasons, dt),
+    labels: mt(e.labels, dt),
+    actions: Vl(e.actions, cr)
+  } : {
+    enabled: !1,
+    items: [...dt],
+    disabled: [],
+    disabledReasons: Object.freeze({}),
+    labels: Object.freeze({}),
+    actions: Object.freeze({})
+  };
+}
+function To(e) {
+  return e.items;
+}
+function zo(e) {
+  return e.disabled;
+}
+function Ho(e) {
+  return e.disabledReasons;
+}
+function Vo(e) {
+  const l = cr.map((a) => [a, Object.freeze({ ...e.actions[a] ?? {} })]).filter(([, a]) => Object.keys(a).length > 0);
+  return Object.freeze(Object.fromEntries(l));
+}
+function ql(e) {
+  return (l) => {
+    e.value = l instanceof HTMLElement ? l : null;
+  };
+}
+function Bo(e) {
+  const l = ql(e.headerViewportRef), a = ql(e.bodyViewportRef), r = (F) => {
+    e.editingCellValueRef.value = F;
+  }, u = w(() => ({
+    gridContentStyle: m(e.gridContentStyle),
+    mainTrackStyle: m(e.mainTrackStyle),
+    indexColumnStyle: m(e.indexColumnStyle),
+    stageStyle: m(e.stageStyle),
+    bodyShellStyle: m(e.bodyShellStyle),
+    columnStyle: m(e.columnStyle)
+  })), i = w(() => ({
+    topSpacerHeight: m(e.topSpacerHeight),
+    bottomSpacerHeight: m(e.bottomSpacerHeight),
+    viewportRowStart: m(e.viewportRowStart),
+    viewportRowEnd: m(e.viewportRowEnd),
+    virtualRowTotal: m(e.virtualRowTotal),
+    baseRowHeight: m(e.baseRowHeight),
+    resolveRowHeight: m(e.resolveRowHeight),
+    resolveRowOffset: m(e.resolveRowOffset),
+    columnWindowStart: m(e.columnWindowStart),
+    leftColumnSpacerWidth: m(e.leftColumnSpacerWidth),
+    rightColumnSpacerWidth: m(e.rightColumnSpacerWidth),
+    headerViewportRef: l,
+    bodyViewportRef: a,
+    handleHeaderWheel: m(e.handleHeaderWheel),
+    handleHeaderScroll: m(e.handleHeaderScroll),
+    handleViewportScroll: m(e.handleViewportScroll),
+    handleViewportKeydown: m(e.handleViewportKeydown)
+  })), g = w(() => ({
+    visibleColumns: m(e.visibleColumns),
+    renderedColumns: m(e.renderedColumns),
+    columnFilterTextByKey: m(e.columnFilterTextByKey),
+    reorderColumnsByHeader: m(e.reorderColumnsByHeader),
+    toggleSortForColumn: m(e.toggleSortForColumn),
+    handleHeaderColumnClick: m(e.handleHeaderColumnClick),
+    sortIndicator: m(e.sortIndicator),
+    setColumnFilterText: m(e.setColumnFilterText),
+    columnMenuEnabled: m(e.columnMenuEnabled),
+    columnMenuTrigger: m(e.columnMenuTrigger),
+    columnMenuValueFilterEnabled: m(e.columnMenuValueFilterEnabled),
+    columnMenuValueFilterRowLimit: m(e.columnMenuValueFilterRowLimit),
+    columnMenuMaxFilterValues: m(e.columnMenuMaxFilterValues),
+    resolveColumnMenuItems: m(e.resolveColumnMenuItems),
+    resolveColumnMenuDisabledItems: m(e.resolveColumnMenuDisabledItems),
+    resolveColumnMenuDisabledReasons: m(e.resolveColumnMenuDisabledReasons),
+    resolveColumnMenuLabels: m(e.resolveColumnMenuLabels),
+    resolveColumnMenuActionOptions: m(e.resolveColumnMenuActionOptions),
+    resolveColumnMenuCustomItems: m(e.resolveColumnMenuCustomItems),
+    isColumnFilterActive: m(e.isColumnFilterActive),
+    isColumnGrouped: m(e.isColumnGrouped),
+    resolveColumnGroupOrder: m(e.resolveColumnGroupOrder),
+    resolveColumnMenuSortDirection: m(e.resolveColumnMenuSortDirection),
+    resolveColumnMenuSelectedTokens: m(e.resolveColumnMenuSelectedTokens),
+    resolveColumnMenuValueEntries: m(e.resolveColumnMenuValueEntries),
+    applyColumnMenuSort: m(e.applyColumnMenuSort),
+    applyColumnMenuPin: m(e.applyColumnMenuPin),
+    applyColumnMenuGroupBy: m(e.applyColumnMenuGroupBy),
+    applyColumnMenuFilter: m(e.applyColumnMenuFilter),
+    clearColumnMenuFilter: m(e.clearColumnMenuFilter),
+    startResize: m(e.startResize),
+    handleResizeDoubleClick: m(e.handleResizeDoubleClick)
+  })), h = w(() => ({
+    displayRows: m(e.displayRows),
+    displayRowsRevision: m(e.displayRowsRevision),
+    runtimeRevision: m(e.runtimeRevision),
+    pinnedBottomRows: m(e.pinnedBottomRows),
+    sourceRows: m(e.sourceRows),
+    showRowIndex: m(e.showRowIndex),
+    rowHover: m(e.rowHover),
+    stripedRows: m(e.stripedRows),
+    rowClass: m(e.rowClass),
+    isRowAutosizeProbe: m(e.isRowAutosizeProbe),
+    rowStyle: m(e.rowStyle),
+    isRowInPendingClipboardCut: m(e.isRowInPendingClipboardCut),
+    isRowFocused: m(e.isRowFocused),
+    isRowCheckboxSelected: m(e.isRowCheckboxSelected),
+    allVisibleRowsSelected: m(e.allVisibleRowsSelected),
+    someVisibleRowsSelected: m(e.someVisibleRowsSelected),
+    handleRowClick: m(e.handleRowClick),
+    handleRowIndexClick: m(e.handleRowIndexClick),
+    handleRowIndexKeydown: m(e.handleRowIndexKeydown),
+    reorderRowsByIndex: m(e.reorderRowsByIndex),
+    handleToggleAllVisibleRows: m(e.handleToggleAllVisibleRows),
+    toggleGroupRow: m(e.toggleGroupRow),
+    rowIndexLabel: m(e.rowIndexLabel),
+    startRowResize: m(e.startRowResize),
+    autosizeRow: m(e.autosizeRow)
+  })), R = w(() => ({
+    selectionRange: m(e.selectionRange),
+    selectionRanges: m(e.selectionRanges),
+    selectionAnchorCell: m(e.selectionAnchorCell),
+    totalRowCount: m(e.totalRowCount),
+    fillPreviewRange: m(e.fillPreviewRange),
+    rangeMovePreviewRange: m(e.rangeMovePreviewRange),
+    fillHandleEnabled: m(e.fillHandleEnabled),
+    rangeMoveEnabled: m(e.rangeMoveEnabled),
+    isFillDragging: m(e.isFillDragging),
+    isRangeMoving: m(e.isRangeMoving),
+    fillActionAnchorCell: m(e.fillActionAnchorCell),
+    fillActionBehavior: m(e.fillActionBehavior),
+    applyFillActionBehavior: m(e.applyFillActionBehavior),
+    isFillHandleCell: m(e.isFillHandleCell),
+    startFillHandleDrag: m(e.startFillHandleDrag),
+    startFillHandleDoubleClick: m(e.startFillHandleDoubleClick)
+  })), E = w(() => ({
+    editingCellValue: e.editingCellValueRef.value,
+    editingCellInitialFilter: m(e.editingCellInitialFilter),
+    editingCellOpenOnMount: m(e.editingCellOpenOnMount),
+    isEditingCell: m(e.isEditingCell),
+    startInlineEdit: m(e.startInlineEdit),
+    updateEditingCellValue: r,
+    handleEditorKeydown: m(e.handleEditorKeydown),
+    handleEditorBlur: m(e.handleEditorBlur),
+    commitInlineEdit: m(e.commitInlineEdit),
+    cancelInlineEdit: m(e.cancelInlineEdit)
+  })), O = w(() => ({
+    cellClass: m(e.cellClass),
+    cellStyle: m(e.cellStyle),
+    isCellSelected: m(e.isCellSelected),
+    isSelectionAnchorCell: m(e.isSelectionAnchorCell),
+    shouldHighlightSelectedCell: m(e.shouldHighlightSelectedCell),
+    isCellOnSelectionEdge: m(e.isCellOnSelectionEdge),
+    isCellInFillPreview: m(e.isCellInFillPreview),
+    isCellInPendingClipboardRange: m(e.isCellInPendingClipboardRange),
+    isCellOnPendingClipboardEdge: m(e.isCellOnPendingClipboardEdge),
+    isCellEditable: m(e.isCellEditable),
+    readCell: m(e.readCell),
+    readDisplayCell: m(e.readDisplayCell)
+  })), G = w(() => ({
+    handleCellMouseDown: m(e.handleCellMouseDown),
+    handleCellClick: m(e.handleCellClick),
+    handleCellKeydown: m(e.handleCellKeydown)
+  })), I = w(() => ({
+    mode: m(e.mode),
+    rowHeightMode: m(e.rowHeightMode),
+    layoutMode: m(e.layoutMode),
+    chromeSignature: m(e.chromeSignature),
+    customOverlays: m(e.customOverlays),
+    reportCenterPaneDiagnostics: m(e.reportCenterPaneDiagnostics),
+    reportFillPlumbingState: m(e.reportFillPlumbingState),
+    reportFillPlumbingDetail: m(e.reportFillPlumbingDetail),
+    layout: u.value,
+    viewport: i.value,
+    columns: g.value,
+    rows: h.value,
+    selection: R.value,
+    editing: E.value,
+    cells: O.value,
+    interaction: G.value
+  })), b = qr({
+    mode: w(() => m(e.mode)),
+    rowHeightMode: w(() => m(e.rowHeightMode)),
+    layoutMode: w(() => m(e.layoutMode)),
+    layout: u,
+    viewport: i,
+    columns: g,
+    rows: h,
+    selection: R,
+    editing: E,
+    cells: O,
+    interaction: G
+  });
+  return {
+    tableStageProps: I,
+    tableStageContext: b,
+    captureHeaderViewportRef: l,
+    captureBodyViewportRef: a,
+    updateEditingCellValue: r
+  };
+}
+function jo(e) {
+  const l = (i, g) => Number.isFinite(i.displayIndex) ? Math.max(0, Math.trunc(i.displayIndex)) : e.viewportRowStart.value + g;
+  return {
+    readStageCell: (i, g) => e.isRowSelectionColumnKey(g) ? e.readRowSelectionCell(i) : e.readCell(i, g),
+    readStageDisplayCell: (i, g) => e.isRowSelectionColumnKey(g) ? e.readRowSelectionDisplayCell(i) : e.readDisplayCell(i, g),
+    handleCellClick: (i, g, h, R) => {
+      if (e.isRowSelectionColumn(h)) {
+        e.toggleRowCheckboxSelected(i);
+        return;
+      }
+      const E = l(i, g), O = e.isCellEditableByKey(i, E, h.key, R), G = Ir({
+        column: h.column,
+        row: i.kind !== "group" ? i.data : void 0,
+        rowId: i.rowId,
+        editable: O
+      });
+      if (G === "invoke") {
+        xr({
+          column: h.column,
+          row: i.kind !== "group" ? i.data : void 0,
+          rowId: i.rowId,
+          editable: O,
+          trigger: "click"
+        });
+        return;
+      }
+      if (G !== "toggle" || i.kind === "group" || i.rowId == null)
+        return;
+      const I = e.captureHistorySnapshot(), b = e.ensureEditableRowAtIndex?.(E) ?? i;
+      if (b.kind === "group" || b.rowId == null)
+        return;
+      const F = b.data[h.key], A = Mr({
+        column: h.column,
+        row: b.data
+      });
+      e.runtime.api.rows.applyEdits([
+        {
+          rowId: b.rowId,
+          data: {
+            [h.key]: A
+          }
+        }
+      ]), e.onCellEdit?.({
+        rowId: b.rowId,
+        columnKey: h.key,
+        oldValue: F,
+        newValue: A,
+        patch: {
+          rowId: b.rowId,
+          data: {
+            [h.key]: A
+          }
+        }
+      }), e.recordHistoryIntentTransaction({
+        intent: "edit",
+        label: `Toggle ${h.key}`,
+        affectedRange: {
+          startRow: E,
+          endRow: E,
+          startColumn: R,
+          endColumn: R
+        }
+      }, I), e.syncViewport();
+    }
+  };
+}
+const Yl = 140, Dn = 108, Sl = "__datagrid_row_selection__";
+function Go(e) {
+  const l = w(() => (e.showRowSelection?.value ?? !0) && e.runtime.api.rowSelection.hasSupport()), a = w(() => l.value ? {
+    key: Sl,
+    state: {
+      visible: !0,
+      pin: "left",
+      width: Dn
+    },
+    visible: !0,
+    pin: "left",
+    width: Dn,
+    column: {
+      key: Sl,
+      label: "",
+      cellType: "checkbox",
+      cellInteraction: {
+        click: !0,
+        keyboard: ["enter", "space"],
+        role: "checkbox",
+        label: "Toggle row selection",
+        checked: ({ rowId: b }) => b != null && e.runtime.api.rowSelection.isSelected(b),
+        onInvoke: ({ rowId: b }) => {
+          b == null || !e.runtime.api.rowSelection.hasSupport() || e.runtime.api.rowSelection.setSelected(
+            b,
+            !e.runtime.api.rowSelection.isSelected(b)
+          );
+        }
+      },
+      minWidth: Dn,
+      maxWidth: Dn,
+      capabilities: {
+        editable: !0,
+        sortable: !1,
+        filterable: !1,
+        groupable: !1,
+        pivotable: !1,
+        aggregatable: !1
+      },
+      presentation: {
+        align: "center",
+        headerAlign: "center"
+      },
+      meta: {
+        isSystem: !0,
+        rowSelection: !0
+      }
+    }
+  } : null), r = (b) => b === Sl, u = (b) => r(b.key), i = w(() => {
+    const b = a.value, F = e.visibleColumns.value.filter((M) => M.pin === "left"), A = e.visibleColumns.value.filter((M) => M.pin !== "left" && M.pin !== "right"), C = e.visibleColumns.value.filter((M) => M.pin === "right");
+    return b ? [b, ...F, ...A, ...C] : [...F, ...A, ...C];
+  }), g = w(() => i.value.filter((b) => b.pin !== "left" && b.pin !== "right")), h = (b) => b.width ?? Yl, R = (b) => {
+    const F = i.value.find((M) => M.key === b), C = `${F ? h(F) : Yl}px`;
+    return {
+      width: C,
+      minWidth: C,
+      maxWidth: C
+    };
+  }, E = (b) => b.column.capabilities?.editable !== !1, O = (b, F, A) => u(A) ? b.kind !== "group" && b.rowId != null : b.kind === "group" || b.rowId == null || !E(A) ? !1 : e.isCellEditable ? e.isCellEditable({
+    row: b.data,
+    rowId: b.rowId,
+    rowIndex: F,
+    column: A.column,
+    columnKey: A.key
+  }) : !0, G = (b, F) => {
+    const A = i.value[F];
+    if (A?.key === b)
+      return { column: A, columnIndex: F };
+    const C = i.value.findIndex((M) => M.key === b);
+    return C < 0 ? null : {
+      column: i.value[C],
+      columnIndex: C
+    };
+  };
+  return {
+    orderedVisibleColumns: i,
+    centerColumns: g,
+    resolveColumnWidth: h,
+    stageColumnStyle: R,
+    isRowSelectionColumnKey: r,
+    isRowSelectionColumn: u,
+    isCellEditable: O,
+    isCellEditableByKey: (b, F, A, C) => {
+      const M = G(A, C);
+      return M ? O(b, F, M.column) : !1;
+    },
+    rowSelectionColumn: a
+  };
+}
+function Lo(e) {
+  const l = w(() => {
+    const r = e.lastAppliedFill.value, u = e.selectionRange.value;
+    return !r || !u || e.isFillDragging.value || r.allowBehaviorToggle === !1 || r.previewRange.startRow !== u.startRow || r.previewRange.endRow !== u.endRow || r.previewRange.startColumn !== u.startColumn || r.previewRange.endColumn !== u.endColumn ? null : {
+      rowIndex: r.previewRange.endRow,
+      columnIndex: r.previewRange.endColumn
+    };
+  }), a = w(() => e.lastAppliedFill.value?.behavior ?? null);
+  return {
+    fillActionAnchorCell: l,
+    fillActionBehavior: a
+  };
+}
+function $o(e) {
+  const l = e.enabled === !1 || e.history ? null : _r({
+    runtime: e.runtime,
+    cloneRowData: e.cloneRowData,
+    syncViewport: e.syncViewport,
+    maxHistoryDepth: e.maxHistoryDepth
+  }), a = () => e.enabled === !1 ? null : e.history ? e.history.captureSnapshot() : l?.captureRowsSnapshot() ?? null, r = (O) => e.enabled === !1 ? null : e.history ? e.history.captureSnapshotForRowIds?.(O) ?? e.history.captureSnapshot() : l?.captureRowsSnapshotByIds(O) ?? null, u = (O, G, I) => {
+    if (e.enabled !== !1) {
+      if (e.history) {
+        e.history.recordIntentTransaction(O, G, I);
+        return;
+      }
+      l?.recordIntentTransaction(
+        O,
+        G,
+        I
+      );
+    }
+  }, i = (O) => {
+    e.enabled !== !1 && e.history?.recordServerFillTransaction?.(O);
+  }, g = () => e.enabled === !1 ? !1 : e.history ? e.history.canUndo() : l?.canUndo.value ?? !1, h = () => e.enabled === !1 ? !1 : e.history ? e.history.canRedo() : l?.canRedo.value ?? !1;
+  return {
+    captureHistorySnapshot: a,
+    captureHistorySnapshotForRowIds: r,
+    recordHistoryIntentTransaction: u,
+    recordServerFillTransaction: i,
+    canUndoHistory: g,
+    canRedoHistory: h,
+    canUndo: g,
+    canRedo: h,
+    runHistoryAction: (O) => e.enabled === !1 ? Promise.resolve(null) : e.history ? e.history.runHistoryAction(O) : l?.runHistoryAction(O) ?? Promise.resolve(null),
+    disposeIntentHistory: () => {
+      l?.dispose();
+    }
+  };
+}
+function Ko(e) {
+  const l = e.isPlaceholderRow ?? (() => !1), a = e.applyRowSelectionMutation ?? ((C) => {
+    e.runtime.api.rowSelection.hasSupport() && C(e.runtime.api.rowSelection);
+  }), r = w(() => new Set(e.rowSelectionSnapshot.value?.selectedRows ?? [])), u = (C) => !l(C) && C.rowId != null && e.rowSelectionSnapshot.value?.focusedRow === C.rowId, i = (C) => !l(C) && C.kind !== "group" && C.rowId != null && r.value.has(C.rowId), g = (C) => i(C), h = (C) => g(C) ? "true" : "false", R = (C) => {
+    const M = e.rowSelectionColumn.value?.column;
+    return !M || C.kind === "group" || l(C) ? "" : Fr({
+      column: M,
+      value: g(C)
+    }).displayValue;
+  }, E = w(() => {
+    const C = e.runtime.api.rows.getCount(), M = [];
+    for (let Y = 0; Y < C; Y += 1) {
+      const ne = e.runtime.api.rows.get(Y);
+      !ne || ne.kind === "group" || ne.rowId == null || M.push(ne.rowId);
+    }
+    return M;
+  }), O = w(() => {
+    const C = E.value;
+    return C.length > 0 && C.every((M) => r.value.has(M));
+  }), G = w(() => E.value.some((M) => r.value.has(M))), I = (C) => {
+    l(C) || C.rowId == null || !e.runtime.api.rowSelection.hasSupport() || e.runtime.api.rowSelection.setFocusedRow(C.rowId);
+  };
+  return {
+    rowSelectionSet: r,
+    isRowFocused: u,
+    isRowCheckboxSelected: i,
+    readRowSelectionCell: h,
+    readRowSelectionDisplayCell: R,
+    areAllVisibleRowsSelected: O,
+    areSomeVisibleRowsSelected: G,
+    focusRow: I,
+    toggleRowCheckboxSelected: (C) => {
+      l(C) || C.kind === "group" || C.rowId == null || !e.runtime.api.rowSelection.hasSupport() || a((M) => {
+        M.setSelected(C.rowId, !r.value.has(C.rowId));
+      });
+    },
+    toggleVisibleRowsSelected: () => {
+      if (!e.runtime.api.rowSelection.hasSupport())
+        return;
+      const C = E.value;
+      if (!O.value) {
+        a((M) => {
+          M.selectRows(C);
+        });
+        return;
+      }
+      a((M) => {
+        M.deselectRows(C);
+      });
+    },
+    selectRowRange: (C, M, Y) => {
+      I(C);
+      const ne = e.orderedVisibleColumns.value.length - 1;
+      if (ne < 0)
+        return;
+      const j = e.viewportRowStart.value + M;
+      if (!Y) {
+        e.applySelectionRange({
+          startRow: j,
+          endRow: j,
+          startColumn: 0,
+          endColumn: ne
+        });
+        return;
+      }
+      const Me = e.selectionAnchorCell.value?.rowIndex ?? j;
+      e.applySelectionRange({
+        startRow: Math.min(Me, j),
+        endRow: Math.max(Me, j),
+        startColumn: 0,
+        endColumn: ne
+      });
+    }
+  };
+}
+function No(e) {
+  const l = (g) => ({ target: g });
+  return {
+    handleWindowMouseMove: (g) => {
+      if (e.isColumnResizing.value) {
+        e.applyColumnResizeFromPointer(g.clientX);
+        return;
+      }
+      e.handleInteractionWindowMouseMove(g);
+    },
+    handleHeaderWheel: (g) => {
+      const h = e.bodyViewportRef.value;
+      if (!h)
+        return;
+      const R = Math.abs(g.deltaX) > 0 ? g.deltaX : g.shiftKey ? g.deltaY : 0, E = R === 0 ? g.deltaY : 0;
+      R === 0 && E === 0 || (g.preventDefault(), R !== 0 && (h.scrollLeft += R), E !== 0 && (h.scrollTop += E), e.syncViewport(l(h)));
+    },
+    handleHeaderScroll: (g) => {
+      const h = g.target, R = e.bodyViewportRef.value;
+      !h || !R || (R.scrollLeft !== h.scrollLeft && (R.scrollLeft = h.scrollLeft), e.syncViewport(l(R)));
+    },
+    handleWindowMouseUp: () => {
+      e.stopColumnResize(), e.handleInteractionWindowMouseUp();
+    }
+  };
+}
+function Wo(e) {
+  const l = (i) => i.ctrlKey || i.metaKey || i.altKey ? !1 : i.key.startsWith("Arrow") || i.key === "Home" || i.key === "End" || i.key === "PageUp" || i.key === "PageDown" || i.key === "Tab" || i.key === "Enter" || i.key === " " || i.key === "Spacebar" || i.key === "F2" || i.key === "Escape" || i.key.length === 1, a = (i) => (i.ctrlKey || i.metaKey) && !i.altKey && !i.shiftKey && i.key.toLowerCase() === "a", r = () => {
+    const i = e.totalRows.value - 1, g = e.orderedVisibleColumns.value.length - 1;
+    i < 0 || g < 0 || e.applySelectionRange({
+      startRow: 0,
+      endRow: i,
+      startColumn: 0,
+      endColumn: g
+    });
+  };
+  return {
+    handleViewportKeydown: (i) => {
+      (l(i) || a(i)) && i.preventDefault();
+      const g = e.selectionSnapshot.value?.activeCell;
+      if (!g) {
+        a(i) && r();
+        return;
+      }
+      const h = e.runtime.getBodyRowAtIndex(g.rowIndex);
+      h && e.handleCellKeydown(
+        i,
+        h,
+        g.rowIndex - e.viewportRowStart.value,
+        g.colIndex
+      );
+    }
+  };
+}
+function Uo(e) {
+  const l = w(() => e.interactionSelectionRange.value ?? e.resolveCommittedSelectionRange()), a = w(() => {
+    const I = e.interactionSelectionRange.value;
+    return I ? [I] : e.resolveCommittedSelectionRanges();
+  }), r = () => {
+    const I = l.value;
+    return I && I.startRow === I.endRow && I.startColumn === I.endColumn ? {
+      rowIndex: I.startRow,
+      columnIndex: I.startColumn
+    } : e.selectionAnchorCell.value;
+  }, u = () => l.value, i = () => a.value, g = () => e.mode.value === "base" && e.isFillDragging.value && !!e.fillPreviewRange.value, h = (I, b, F) => {
+    const A = e.viewportRowStart.value + b;
+    return A >= I.startRow && A <= I.endRow && F >= I.startColumn && F <= I.endColumn;
+  }, R = (I, b) => {
+    const F = r();
+    return F ? F.rowIndex === e.viewportRowStart.value + I && F.columnIndex === b : e.isCommittedSelectionAnchorCell(I, b);
+  };
+  return {
+    selectionRange: l,
+    selectionRanges: a,
+    isSelectionAnchorCell: R,
+    isCellSelected: (I, b) => {
+      if (!g())
+        return i().some((A) => h(A, I, b));
+      const F = u();
+      return F ? h(F, I, b) : !1;
+    },
+    shouldHighlightSelectedCell: (I, b) => {
+      if (!g()) {
+        const C = i();
+        return C.length === 0 || !C.some((M) => h(M, I, b)) || C.length === 1 && C[0] && C[0].startRow === C[0].endRow && C[0].startColumn === C[0].endColumn ? !1 : !R(I, b);
+      }
+      const F = u();
+      return !F || !h(F, I, b) || F.startRow === F.endRow && F.startColumn === F.endColumn ? !1 : !R(I, b);
+    },
+    isCellOnSelectionEdge: (I, b, F) => {
+      if (!g())
+        return i().some((M) => {
+          if (!h(M, I, b))
+            return !1;
+          const Y = e.viewportRowStart.value + I;
+          switch (F) {
+            case "top":
+              return Y === M.startRow;
+            case "right":
+              return b === M.endColumn;
+            case "bottom":
+              return Y === M.endRow;
+            case "left":
+              return b === M.startColumn;
+          }
+        });
+      const A = u();
+      if (!A || !h(A, I, b))
+        return !1;
+      const C = e.viewportRowStart.value + I;
+      switch (F) {
+        case "top":
+          return C === A.startRow;
+        case "right":
+          return b === A.endColumn;
+        case "bottom":
+          return C === A.endRow;
+        case "left":
+          return b === A.startColumn;
+      }
+    }
+  };
+}
+const Il = 140, qo = 72, Yo = 80, Jo = 24, Xo = 400;
+function Zo(e) {
+  const l = e.syncRowSelectionSnapshotFromRuntime ?? (() => {
+  }), a = e.flushRowSelectionSnapshotUpdates ?? (() => {
+  }), r = e.rowSelectionSnapshot ?? q(null), u = q(null), i = w(() => e.showRowIndex?.value !== !1), g = w(() => e.runtime.rowPartition.value.bodyRowCount), h = Yr({
+    runtime: e.runtime,
+    sourceRows: e.sourceRows ?? e.rows,
+    totalBodyRows: g,
+    placeholderRows: e.placeholderRows,
+    cloneRowData: e.cloneRowData
+  }), R = w(() => Math.max(0, h.totalVisualRows.value)), E = w(() => Math.max(0, R.value + e.runtime.rowPartition.value.pinnedBottomRows.length)), O = w(() => i.value ? qo : 0), G = Go({
+    runtime: e.runtime,
+    visibleColumns: e.visibleColumns,
+    showRowSelection: e.showRowSelection,
+    isCellEditable: e.isCellEditable
+  }), {
+    orderedVisibleColumns: I,
+    centerColumns: b,
+    resolveColumnWidth: F,
+    isRowSelectionColumnKey: A,
+    isRowSelectionColumn: C,
+    isCellEditable: M,
+    isCellEditableByKey: Y,
+    rowSelectionColumn: ne
+  } = G, j = kr({
+    totalRows: () => R.value,
+    resolveBaseRowHeight: () => e.normalizedBaseRowHeight.value,
+    resolveRowHeightOverride: (c) => e.runtime.api.view.getRowHeightOverride(c),
+    resolveRowHeightVersion: () => e.runtime.api.view.getRowHeightVersion(),
+    hasRowHeightOverrides: () => e.runtime.api.view.getRowHeightVersion() > 0,
+    resolveRowHeightOverridesSnapshot: () => e.runtime.api.view.getRowHeightOverridesSnapshot?.() ?? null,
+    resolveLastRowHeightMutation: () => e.runtime.api.view.getLastRowHeightMutation?.() ?? null
+  }), Me = (c) => {
+    const y = Math.max(0, Math.trunc(c));
+    if (y <= 0)
+      return 0;
+    const S = j.resolveTotalHeight();
+    return y <= g.value ? j.resolveRowOffset(y) : S + (y - g.value) * e.normalizedBaseRowHeight.value;
+  }, ft = w(() => {
+    if (e.layoutMode.value !== "auto-height")
+      return null;
+    let c = j.resolveTotalHeight();
+    return e.minRows.value !== null && (c = Math.max(c, Me(e.minRows.value))), e.maxRows.value !== null && (c = Math.min(c, Me(e.maxRows.value))), Math.max(0, Math.trunc(c));
+  }), wt = w(() => e.layoutMode.value !== "auto-height" ? {} : {
+    height: "auto"
+  }), We = w(() => {
+    if (e.layoutMode.value !== "auto-height")
+      return {};
+    const c = ft.value ?? 0;
+    return {
+      height: `${c}px`,
+      maxHeight: `${c}px`
+    };
+  });
+  let T = () => !1;
+  const {
+    headerViewportRef: z,
+    bodyViewportRef: _,
+    displayRows: le,
+    displayRowsRevision: Pn,
+    renderedViewportRange: gt,
+    pinnedBottomRows: se,
+    renderedColumns: Bt,
+    viewportRowStart: N,
+    viewportRowEnd: tt,
+    viewportColumnStart: nt,
+    topSpacerHeight: Tn,
+    bottomSpacerHeight: zn,
+    leftColumnSpacerWidth: Hn,
+    rightColumnSpacerWidth: Vn,
+    gridContentStyle: Bn,
+    mainTrackStyle: jn,
+    indexColumnStyle: Gn,
+    columnStyle: Ln,
+    handleViewportScroll: Fe,
+    syncRenderedRowsInRange: J,
+    syncViewportFromDom: re,
+    scheduleViewportSync: lt,
+    cancelScheduledViewportSync: jt
+  } = Er({
+    runtime: h.visualRuntime,
+    mode: e.mode,
+    rowRenderMode: e.rowRenderMode,
+    rowVirtualizationEnabled: w(() => e.virtualization.value.rows),
+    columnVirtualizationEnabled: w(() => e.virtualization.value.columns),
+    totalRows: R,
+    visibleColumns: b,
+    sizingColumns: I,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    resolveColumnWidth: F,
+    defaultColumnWidth: Il,
+    indexColumnWidth: 0,
+    flexFillOffsetWidth: O.value,
+    rowOverscan: w(() => e.virtualization.value.rowOverscan),
+    columnOverscan: w(() => e.virtualization.value.columnOverscan),
+    measureVisibleRowHeights: () => vt(),
+    resolveRowHeight: j.resolveRowHeight,
+    resolveRowOffset: j.resolveRowOffset,
+    resolveRowIndexAtOffset: j.resolveRowIndexAtOffset,
+    resolveTotalRowHeight: j.resolveTotalHeight
+  }), Gt = w(() => (e.rowVersion.value, e.runtime.rowPartition.value, e.runtimeRowModel?.getSnapshot?.().revision ?? e.runtime.api.rows.getSnapshot().revision ?? null)), Ue = (c) => {
+    if ("renderedViewport" in c && c.renderedViewport && (u.value = {
+      startRow: Math.max(0, Math.trunc(c.renderedViewport.start)),
+      endRow: Math.max(Math.max(0, Math.trunc(c.renderedViewport.start)), Math.trunc(c.renderedViewport.end))
+    }, e.reportFillPlumbingDetail?.("centerPaneStoredRenderedViewport", Dt(u.value))), typeof c.debugJson == "string" && c.debugJson.length > 0)
+      try {
+        const y = JSON.parse(c.debugJson), S = y.renderedViewport?.start, D = y.renderedViewport?.end;
+        u.value == null && Number.isFinite(S) && Number.isFinite(D) && (u.value = {
+          startRow: Math.max(0, Math.trunc(S)),
+          endRow: Math.max(Math.max(0, Math.trunc(S)), Math.trunc(D))
+        }, e.reportFillPlumbingDetail?.("centerPaneStoredRenderedViewport", Dt(u.value)));
+      } catch {
+      }
+    e.reportCenterPaneDiagnostics?.(c);
+  }, Lt = (c) => Ln(c), W = h.visualRuntime, $t = W.resolveBodyRowIndexById, Kt = (c) => {
+    if (!Number.isFinite(c))
+      return null;
+    const y = Math.max(0, Math.trunc(c));
+    if (y < R.value)
+      return W.getBodyRowAtIndex(y);
+    const S = y - R.value;
+    return e.runtime.rowPartition.value.pinnedBottomRows[S] ?? null;
+  }, {
+    rowStyle: Nt,
+    isRowAutosizeProbe: Wt,
+    measureVisibleRowHeights: vt,
+    startRowResize: Ut,
+    autosizeRow: qt,
+    consumeRecentRowResizeInteraction: Yt,
+    dispose: Jt
+  } = Pr({
+    mode: e.mode,
+    rowHeightMode: e.rowHeightMode,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    viewportRowStart: N,
+    bodyViewportRef: _,
+    runtime: e.runtime,
+    minRowHeight: Jo,
+    syncViewport: () => re()
+  }), de = Tr({
+    mode: e.mode,
+    runtime: {
+      api: W.api,
+      getBodyRowAtIndex: Kt
+    },
+    totalRows: E,
+    visibleColumns: I,
+    viewportRowStart: N,
+    resolveRowIndex: (c) => {
+      const y = le.value[c];
+      return y && Number.isFinite(y.displayIndex) ? Math.max(0, Math.trunc(y.displayIndex)) : N.value + c;
+    },
+    selectionSnapshot: e.selectionSnapshot,
+    selectionAnchor: e.selectionAnchor,
+    isEditingCell: (c, y) => T(c, y)
+  }), {
+    normalizeRowId: Xt,
+    normalizeCellCoord: Zt,
+    resolveSelectionRange: rt,
+    resolveSelectionRanges: ot,
+    resolveCurrentCellCoord: $n,
+    applySelectionRange: qe,
+    applyCellSelectionByCoord: Qt,
+    setCellSelection: Kn,
+    clearCellSelection: en,
+    isCellSelected: tn
+  } = de, Nn = de.isSelectionAnchorCell ?? (() => !1), Wn = de.shouldHighlightSelectedCell ?? ((c, y) => tn(c, y)), nn = de.isCellOnSelectionEdge ?? (() => !1), ht = w(() => {
+    const c = e.selectionSnapshot.value;
+    if (!c || c.ranges.length === 0)
+      return null;
+    const y = c.activeRangeIndex ?? 0, S = c.ranges[y]?.anchor ?? c.ranges[0]?.anchor ?? null;
+    return !S || typeof S.rowIndex != "number" || typeof S.colIndex != "number" || !Number.isFinite(S.rowIndex) || !Number.isFinite(S.colIndex) ? null : {
+      rowIndex: Math.trunc(S.rowIndex),
+      columnIndex: Math.trunc(S.colIndex)
+    };
+  }), ln = Ko({
+    runtime: e.runtime,
+    isPlaceholderRow: h.isPlaceholderRow,
+    rowSelectionColumn: ne,
+    orderedVisibleColumns: I,
+    displayRows: le,
+    rowSelectionSnapshot: r,
+    applyRowSelectionMutation: (c) => {
+      e.runtime.api.rowSelection.hasSupport() && (c(e.runtime.api.rowSelection), l(), a());
+    },
+    viewportRowStart: N,
+    selectionAnchorCell: ht,
+    applySelectionRange: qe
+  }), {
+    readRowSelectionCell: Un,
+    readRowSelectionDisplayCell: qn,
+    toggleRowCheckboxSelected: Yn
+  } = ln, rn = w(() => {
+    const c = `${O.value}px`;
+    return {
+      ...Gn.value,
+      width: c,
+      minWidth: c,
+      maxWidth: c
+    };
+  }), at = $o({
+    runtime: e.runtime,
+    cloneRowData: e.cloneRowData,
+    syncViewport: () => re(),
+    enabled: e.historyEnabled?.value !== !1,
+    maxHistoryDepth: e.historyMaxDepth?.value,
+    history: e.history
+  }), {
+    captureHistorySnapshot: Ae,
+    captureHistorySnapshotForRowIds: Be,
+    recordHistoryIntentTransaction: De,
+    canUndoHistory: bt,
+    canRedoHistory: pe,
+    runHistoryAction: ae
+  } = at, je = q(null), ve = q(null), yt = w(() => {
+    const c = je.value;
+    return c?.affectedRange ? [{
+      key: "server-fill-affected-range",
+      ranges: [c.affectedRange],
+      className: "grid-selection-overlay--server-fill",
+      segmentClassName: "grid-selection-overlay__segment--server-fill",
+      borderColor: "color-mix(in srgb, var(--datagrid-accent-strong) 72%, var(--datagrid-text-color) 28%)",
+      backgroundColor: "color-mix(in srgb, var(--datagrid-accent-strong) 10%, transparent)",
+      borderStyle: "solid",
+      hideSingleCell: !1,
+      zIndex: 7
+    }] : [];
+  }), {
+    rowIndexLabel: on,
+    readCell: an,
+    readDisplayCell: Jn,
+    rowClass: Xn,
+    toggleGroupRow: Ye
+  } = zr({
+    mode: e.mode,
+    runtime: e.runtime,
+    viewportRowStart: N,
+    firstColumnKey: e.firstColumnKey
+  }), Ge = jo({
+    runtime: e.runtime,
+    viewportRowStart: N,
+    ensureEditableRowAtIndex: (c) => h.ensureMaterializedRowAt(c, "toggle"),
+    isRowSelectionColumnKey: A,
+    isRowSelectionColumn: C,
+    isCellEditableByKey: Y,
+    readRowSelectionCell: Un,
+    readRowSelectionDisplayCell: qn,
+    readCell: an,
+    readDisplayCell: Jn,
+    toggleRowCheckboxSelected: Yn,
+    captureHistorySnapshot: Ae,
+    captureHistorySnapshotForRowIds: Be,
+    recordHistoryIntentTransaction: De,
+    syncViewport: () => re()
+  }), {
+    readStageCell: Rt
+  } = Ge, sn = (c, y, S) => h.isPlaceholderRow(c) ? h.isPlaceholderCellEditable(y) : S(), Ct = (c, y, S, D) => sn(
+    c,
+    I.value[D],
+    () => Y(c, y, S, D)
+  ), Zn = Hr({
+    mode: e.mode,
+    runtime: W,
+    totalRows: R,
+    visibleColumns: I,
+    viewportRowStart: N,
+    resolveSelectionRange: rt,
+    resolveSelectionRanges: ot,
+    resolveCurrentCellCoord: $n,
+    applySelectionRange: qe,
+    clearCellSelection: en,
+    captureRowsSnapshot: Ae,
+    captureRowsSnapshotForRowIds: Be,
+    recordEditTransaction: (c, y, S) => {
+      De({
+        intent: "edit",
+        label: S ?? "Cell edit"
+      }, c, y);
+    },
+    readCell: (c, y) => Rt(c, y),
+    readClipboardCell: e.readClipboardCell ? (c, y) => e.readClipboardCell?.(c, y) ?? "" : void 0,
+    isCellEditable: Ct,
+    syncViewport: () => re(),
+    applyClipboardEdits: e.applyClipboardEdits,
+    buildFillMatrixFromRange: e.buildFillMatrixFromRange,
+    buildPasteSpecialMatrixFromRange: e.buildPasteSpecialMatrixFromRange,
+    ensureEditableRowAtIndex: (c) => h.ensureMaterializedRowAt(c, "paste")
+  }), {
+    normalizeClipboardRange: pt,
+    applyClipboardEdits: un,
+    rangesEqual: dn,
+    buildFillMatrixFromRange: it,
+    clearPendingClipboardOperation: St,
+    copySelectedCells: cn,
+    pasteSelectedCells: mn,
+    cutSelectedCells: It,
+    isCellInPendingClipboardRange: fn,
+    isCellOnPendingClipboardEdge: Se
+  } = Zn, {
+    ensureKeyboardActiveCellVisible: Oe,
+    revealCellInComfortZone: st
+  } = Vr({
+    bodyViewportRef: _,
+    visibleColumns: I,
+    resolveColumnWidth: F,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    resolveRowHeight: j.resolveRowHeight,
+    resolveRowOffset: j.resolveRowOffset,
+    indexColumnWidth: O.value,
+    defaultColumnWidth: Il,
+    syncViewport: () => re()
+  }), {
+    editingCell: he,
+    editingCellValue: Le,
+    editingCellInitialFilter: xt,
+    editingCellOpenOnMount: Qn,
+    isEditingCell: wn,
+    startInlineEdit: Mt,
+    appendInlineEditTextInput: gn,
+    commitInlineEdit: Ft,
+    cancelInlineEdit: ut,
+    handleEditorKeydown: vn,
+    handleEditorBlur: el
+  } = Br({
+    mode: e.mode,
+    bodyViewportRef: _,
+    visibleColumns: I,
+    totalRows: R,
+    runtime: W,
+    readCell: (c, y) => Rt(c, y),
+    resolveRowIndexById: $t,
+    applyCellSelection: (c) => {
+      Qt(c, !1);
+    },
+    ensureActiveCellVisible: (c, y) => {
+      Oe(c, y);
+    },
+    isCellEditable: Ct,
+    captureRowsSnapshot: Ae,
+    captureRowsSnapshotForRowIds: Be,
+    recordEditTransaction: (c, y, S) => {
+      De({
+        intent: "edit",
+        label: S ?? "Cell edit"
+      }, c, y);
+    },
+    ensureEditableRowAtIndex: (c) => h.ensureMaterializedRowAt(c, "edit"),
+    onCellEdit: e.onCellEdit
+  });
+  T = wn;
+  const Je = w(() => he.value);
+  Rr(() => {
+    e.reportFillPlumbingState?.("runtime_diagnostics_alive", !0), e.reportFillPlumbingDetail?.("runtime_diagnostics_alive", "yes");
+  });
+  function Ie() {
+    const c = e.runtime.api.rows.getSnapshot();
+    return {
+      sortModel: c.sortModel ?? [],
+      filterModel: c.filterModel ?? null,
+      groupBy: c.groupBy ?? null,
+      groupExpansion: c.groupExpansion ?? { expandedByDefault: !1, toggledGroupKeys: [] },
+      treeData: null,
+      pivot: null,
+      pagination: c.pagination ?? {
+        enabled: !1,
+        pageSize: 0,
+        currentPage: 0,
+        pageCount: 0,
+        totalRowCount: 0,
+        startIndex: 0,
+        endIndex: 0
+      }
+    };
+  }
+  function $e() {
+    const c = e.runtimeRowModel?.getSnapshot?.();
+    if (!c)
+      return "none";
+    const y = c.viewportRange;
+    return [
+      `rowCount=${c.rowCount}`,
+      `loading=${c.loading ? "yes" : "no"}`,
+      `viewport=${y.start}..${y.end}`,
+      `revision=${c.revision ?? "none"}`
+    ].join(" ");
+  }
+  function hn(c) {
+    return !c || c.kind === "group" ? "none" : String(c.row.region ?? c.data.region ?? "none");
+  }
+  function Xe(c) {
+    return c ? `${String(c.rowId)}:${hn(c)}` : "none";
+  }
+  function At() {
+    const c = le.value;
+    if (c.length === 0)
+      return null;
+    const y = c[0], S = c[c.length - 1], D = y && Number.isFinite(y.displayIndex) ? Math.max(0, Math.trunc(y.displayIndex)) : null, ee = S && Number.isFinite(S.displayIndex) ? Math.max(0, Math.trunc(S.displayIndex)) : null, U = D ?? N.value, V = ee != null ? Math.max(U, ee) : Math.max(U, U + c.length - 1);
+    return {
+      startRow: U,
+      endRow: V,
+      startColumn: 0,
+      endColumn: Math.max(0, e.visibleColumns.value.length - 1)
+    };
+  }
+  function tl(c) {
+    const S = W.resolveBodyRowIndexById("srv-000025"), D = S >= 0 ? W.getBodyRowAtIndex(S) : null, ee = D && D.kind !== "group" ? String(D.row.region ?? "none") : "none", U = [
+      W.getBodyRowAtIndex(0),
+      W.getBodyRowAtIndex(1),
+      W.getBodyRowAtIndex(2),
+      W.getBodyRowAtIndex(3),
+      W.getBodyRowAtIndex(4)
+    ].filter((ge) => ge != null).map((ge) => String(ge.rowId)).join(", ");
+    e.reportFillPlumbingDetail?.("runtime_viewport_range", `${N.value}..${tt.value}`), e.reportFillPlumbingDetail?.("runtime_rowModel_snapshot", $e()), e.reportFillPlumbingDetail?.("runtime_visible_first5", U || "none"), e.reportFillPlumbingDetail?.("runtime_sample_row25_visible_index", S >= 0 ? String(S) : "none"), e.reportFillPlumbingDetail?.("runtime_sample_row25_region", ee);
+    const V = e.runtime.getBodyRowAtIndex(1), $ = e.runtime.syncBodyRowsInRange({
+      start: 0,
+      end: Math.min(23, Math.max(0, e.runtime.rowPartition.value.bodyRowCount - 1))
+    }), ue = $.find((ge) => Math.trunc(ge.displayIndex) === 1) ?? $[1] ?? null, X = e.runtime.getBodyRowAtIndex(1), ye = le.value[1] ?? null;
+    e.reportFillPlumbingDetail?.(
+      "server_fill_row1_cache_status",
+      V != null && ue != null && V === ue ? "cache-hit" : "pulled-fresh"
+    ), e.reportFillPlumbingDetail?.("server_fill_row1_sync_value", Xe(ue)), e.reportFillPlumbingDetail?.("source_body_row1", Xe(X)), e.reportFillPlumbingDetail?.("source_body_row1_identity", [
+      `before=${Xe(V)}`,
+      `sameDisplay=${X != null && ye != null && X === ye ? "yes" : "no"}`,
+      `sameSync=${X != null && ue != null && X === ue ? "yes" : "no"}`,
+      `revision=${Gt.value ?? "none"}`
+    ].join(" ")), e.reportFillPlumbingDetail?.("source_sync_row1", Xe(ue)), e.reportFillPlumbingState?.("runtime_redraw_happened", !0), e.reportFillPlumbingDetail?.("runtime_redraw_reason", c);
+  }
+  async function bn(c) {
+    const y = e.runtimeRowModel, S = e.runtime.api.rows, D = u.value ? {
+      startRow: u.value.startRow,
+      endRow: u.value.endRow,
+      endColumn: Math.max(0, e.visibleColumns.value.length - 1)
+    } : null, ee = gt.value ? {
+      startRow: gt.value.start,
+      endRow: gt.value.end,
+      endColumn: Math.max(0, e.visibleColumns.value.length - 1)
+    } : null, U = At(), V = D ?? ee ?? U ?? {
+      startRow: N.value,
+      endRow: tt.value,
+      endColumn: Math.max(0, e.visibleColumns.value.length - 1)
+    };
+    e.reportFillPlumbingDetail?.("server_fill_latest_rendered_viewport", Dt(u.value)), e.reportFillPlumbingDetail?.("server_fill_runtime_rendered_viewport", Ke(ee)), e.reportFillPlumbingDetail?.("server_fill_displayrows_rendered_viewport", Ke(U)), e.reportFillPlumbingDetail?.("server_fill_selected_rendered_viewport", Ke(V)), e.reportFillPlumbingDetail?.("server_fill_refresh_used_stored_rendered", D ? "yes" : "no");
+    const $ = yn(c) ?? yn({
+      startRow: V.startRow,
+      endRow: V.endRow
+    });
+    e.reportFillPlumbingDetail?.("server_fill_raw_invalidation", c ? JSON.stringify(c) : "none"), e.reportFillPlumbingDetail?.("server_fill_invalidation_range", $ ? `${$.start}..${$.end}` : "none"), e.reportFillPlumbingDetail?.("server_fill_normalized_invalidation", $ ? `${$.start}..${$.end}` : "none"), e.reportFillPlumbingDetail?.("server_fill_sync_input_range", Ke(V)), e.reportFillPlumbingDetail?.("server_fill_runtime_rowModel_invalidate_type", typeof y?.invalidateRange == "function" ? "function" : typeof y?.invalidateRange);
+    const ue = e.runtime.getBodyRowAtIndex(1);
+    let X = !1;
+    $ && typeof y?.invalidateRange == "function" && (y.invalidateRange($), X = !0);
+    const ye = e.runtime.getBodyRowAtIndex(1);
+    e.reportFillPlumbingState?.("server_fill_invalidation_called", X), e.reportFillPlumbingDetail?.("server_fill_cache_row1_before_invalidation", ue ? "yes" : "no"), e.reportFillPlumbingDetail?.("server_fill_cache_row1_after_invalidation", ye ? "yes" : "no"), e.reportFillPlumbingState?.("server_fill_invalidation_applied", X), typeof S.refresh == "function" && await S.refresh(), V && (e.runtime.setViewportRange?.({
+      start: V.startRow,
+      end: V.endRow
+    }), e.reportFillPlumbingDetail?.("server_fill_rendered_viewport", Ke(V))), V ? J({
+      start: V.startRow,
+      end: V.endRow
+    }) : re(), await et(), tl("server-fill-refresh");
+  }
+  function Dt(c) {
+    return c ? `${c.startRow}..${c.endRow}` : "none";
+  }
+  function Ke(c) {
+    return c ? `${c.startRow}..${c.endRow}` : "none";
+  }
+  function yn(c) {
+    if (!c)
+      return null;
+    const y = c, S = Number.isFinite(y.startRow) ? y.startRow : y.start, D = Number.isFinite(y.endRow) ? y.endRow : y.end, ee = Number(S), U = Number(D ?? S);
+    return !Number.isFinite(ee) || !Number.isFinite(U) ? null : {
+      start: Math.max(0, Math.trunc(ee)),
+      end: Math.max(Math.max(0, Math.trunc(ee)), Math.trunc(U))
+    };
+  }
+  function Rn(c) {
+    return c ? c.endRow >= N.value && c.startRow <= tt.value : !1;
+  }
+  const Ot = () => (e.historyShortcuts?.value ?? "grid") !== "grid" ? !1 : bt() || ve.value === "committed", _t = () => (e.historyShortcuts?.value ?? "grid") !== "grid" ? !1 : pe() || ve.value === "undone", kt = (c) => {
+    if ((e.historyShortcuts?.value ?? "grid") !== "grid")
+      return Promise.resolve(null);
+    if (je.value && (c === "undo" || c === "redo") && (c === "undo" && ve.value === "committed" || c === "redo" && ve.value === "undone")) {
+      const S = je.value, D = e.runtimeRowModel?.dataSource, ee = Ie(), U = c === "undo" ? D?.undoFillOperation : D?.redoFillOperation;
+      if (U)
+        return Promise.resolve(U({
+          operationId: S.operationId,
+          revision: S.revision,
+          projection: ee
+        })).then(async (V) => {
+          const $ = V?.invalidation?.kind === "range" ? V.invalidation.range : S.affectedRange ?? null;
+          return e.reportFillPlumbingDetail?.("server_fill_affected_range", Ke($)), e.reportFillPlumbingDetail?.("server_fill_visible_overlap", Rn($) ? "yes" : "no"), await bn($), ve.value = c === "undo" ? "undone" : "committed", S.operationId;
+        });
+    }
+    return ae(c);
+  }, Cn = async (c, y) => {
+    const S = pt(c), D = pt(y);
+    if (!S || !D || dn(S, D))
+      return !1;
+    const ee = it(S), U = S.endRow - S.startRow + 1, V = S.endColumn - S.startColumn + 1, $ = /* @__PURE__ */ new Map();
+    for (let t = 0; t < U; t += 1) {
+      let n = !1;
+      for (let o = 0; o < V; o += 1)
+        if ((ee[t]?.[o] ?? "").length > 0) {
+          n = !0;
+          break;
+        }
+      $.set(D.startRow + t, n);
+    }
+    const ue = Ae(), X = /* @__PURE__ */ new Map();
+    let ye = 0, ge = 0;
+    const Fn = (t) => {
+      const n = X.get(t);
+      if (n)
+        return n;
+      const o = {};
+      return X.set(t, o), o;
+    };
+    for (let t = S.startRow; t <= S.endRow; t += 1) {
+      const n = W.getBodyRowAtIndex(t);
+      if (!(!n || n.kind === "group" || n.rowId == null || h.isPlaceholderRow(n)))
+        for (let o = S.startColumn; o <= S.endColumn; o += 1) {
+          const s = I.value[o]?.key;
+          !s || A(s) || (Fn(n.rowId)[s] = "");
+        }
+    }
+    for (let t = D.startRow; t <= D.endRow; t += 1) {
+      let n = W.getBodyRowAtIndex(t);
+      h.isPlaceholderRow(n) && $.get(t) === !0 && (n = h.ensureMaterializedRowAt(t, "paste"));
+      for (let o = D.startColumn; o <= D.endColumn; o += 1) {
+        const s = I.value[o]?.key;
+        if (!s || A(s))
+          continue;
+        const d = t - D.startRow, v = o - D.startColumn, f = ee[d]?.[v] ?? "";
+        if (!n || n.kind === "group" || n.rowId == null || h.isPlaceholderRow(n)) {
+          ye += 1;
+          continue;
+        }
+        Fn(n.rowId)[s] = f, ge += 1;
+      }
+    }
+    return ge <= 0 || X.size === 0 ? !1 : (await e.runtime.api.rows.applyEdits(Array.from(X.entries()).map(([t, n]) => ({
+      rowId: t,
+      data: n
+    }))), qe(D), De({
+      intent: "move",
+      label: ye > 0 ? `Move ${ge} cells (blocked ${ye})` : `Move ${ge} cells`,
+      affectedRange: D
+    }, ue), re(), !0);
+  }, Et = {
+    mode: e.mode,
+    enableFillHandle: e.enableFillHandle,
+    enableRangeMove: e.enableRangeMove,
+    runtime: W,
+    totalRows: R,
+    visibleColumns: I,
+    viewportRowStart: N,
+    selectionSnapshot: e.selectionSnapshot,
+    bodyViewportRef: _,
+    indexColumnWidth: O.value,
+    resolveColumnWidth: F,
+    resolveRowHeight: j.resolveRowHeight,
+    resolveRowIndexAtOffset: j.resolveRowIndexAtOffset,
+    normalizeRowId: Xt,
+    normalizeCellCoord: Zt,
+    resolveSelectionRange: rt,
+    applySelectionRange: qe,
+    applyCellSelectionByCoord: Qt,
+    setCellSelection: Kn,
+    clearCellSelection: en,
+    readCell: (c, y) => Rt(c, y),
+    isCellEditable: Ct,
+    cloneRowData: e.cloneRowData,
+    resolveRowIndexById: $t,
+    isRowMaterializedAtIndex: (c) => {
+      const y = W.getBodyRowAtIndex(c);
+      return !!y && y.__placeholder !== !0;
+    },
+    resolveFillBoundary: (() => {
+      const y = e.runtimeRowModel?.dataSource?.resolveFillBoundary;
+      if (e.reportFillPlumbingState?.("stage_runtime_rowmodel", typeof y == "function"), typeof y == "function")
+        return async (S) => {
+          const D = e.runtime.api.rows.getSnapshot();
+          return y({
+            ...S,
+            projection: {
+              sortModel: D.sortModel ?? [],
+              filterModel: D.filterModel ?? null,
+              groupBy: D.groupBy ?? null,
+              groupExpansion: D.groupExpansion ?? { expandedByDefault: !1, toggledGroupKeys: [] },
+              treeData: null,
+              pivot: null,
+              pagination: D.pagination ?? {
+                enabled: !1,
+                pageSize: 0,
+                currentPage: 0,
+                pageCount: 0,
+                totalRowCount: 0,
+                startIndex: 0,
+                endIndex: 0
+              }
+            }
+          });
+        };
+    })(),
+    runtimeRowModel: e.runtimeRowModel ?? null,
+    reportFillWarning: e.reportFillWarning,
+    reportCenterPaneDiagnostics: Ue,
+    reportFillPlumbingState: e.reportFillPlumbingState,
+    reportFillPlumbingDetail: e.reportFillPlumbingDetail,
+    ensureEditableRowAtIndex: (c) => h.ensureMaterializedRowAt(c, "toggle"),
+    captureRowsSnapshot: Ae,
+    captureRowsSnapshotForRowIds: Be,
+    recordIntentTransaction: (c, y, S) => {
+      je.value = null, ve.value = null, De(c, y, S);
+    },
+    recordServerFillTransaction: (c) => {
+      at.recordServerFillTransaction(c), je.value = {
+        operationId: c.operationId,
+        revision: c.revision,
+        affectedRange: c.affectedRange ?? null,
+        mode: c.mode
+      }, ve.value = "committed";
+    },
+    clearPendingClipboardOperation: St,
+    clearExternalPendingClipboardOperation: e.clearExternalPendingClipboardOperation,
+    copySelectedCells: cn,
+    pasteSelectedCells: mn,
+    cutSelectedCells: It,
+    normalizeClipboardRange: pt,
+    applyClipboardEdits: un,
+    rangesEqual: dn,
+    buildFillMatrixFromRange: it,
+    applyRangeMove: e.applyRangeMove ?? Cn,
+    refreshServerFillViewport: bn,
+    syncViewport: () => re(),
+    editingCell: Je,
+    startInlineEdit: Mt,
+    appendInlineEditTextInput: gn,
+    cancelInlineEdit: ut,
+    commitInlineEdit: Ft,
+    canUndo: Ot,
+    canRedo: _t,
+    runHistoryAction: kt,
+    ensureKeyboardActiveCellVisible: Oe,
+    isContextMenuVisible: e.isContextMenuVisible,
+    closeContextMenu: e.closeContextMenu,
+    openContextMenuFromCurrentCell: e.openContextMenuFromCurrentCell,
+    runRowIndexKeyboardAction: e.runRowIndexKeyboardAction
+  }, nl = jr(Et), {
+    isPointerSelectingCells: Ze,
+    isFillDragging: _e,
+    fillPreviewRange: ke,
+    lastAppliedFill: ll,
+    isRangeMoving: rl,
+    selectionRange: ol,
+    rangeMovePreviewRange: al,
+    stopPointerSelection: we,
+    stopFillSelection: il,
+    startFillHandleDrag: pn,
+    startFillHandleDoubleClick: sl,
+    applyLastFillBehavior: ul,
+    handleCellMouseDown: Pt,
+    handleCellKeydown: Sn,
+    handleRowIndexKeydown: ie,
+    handleWindowMouseMove: xe,
+    handleWindowMouseUp: L,
+    isCellInFillPreview: ce,
+    isFillHandleCell: In,
+    clearSelectedCells: dl,
+    dispose: Ee
+  } = nl, Tt = w(() => Ze.value ? ol.value : null), cl = Wo({
+    runtime: W,
+    selectionSnapshot: e.selectionSnapshot,
+    totalRows: R,
+    orderedVisibleColumns: I,
+    viewportRowStart: N,
+    applySelectionRange: qe,
+    handleCellKeydown: Sn
+  }), {
+    isColumnResizing: ml,
+    startResize: fl,
+    handleResizeDoubleClick: wl,
+    applyColumnResizeFromPointer: be,
+    stopColumnResize: xn,
+    dispose: gl
+  } = Gr({
+    visibleColumns: I,
+    rows: e.rows,
+    persistColumnWidth: (c, y) => {
+      e.runtime.api.columns.setWidth(c, y);
+    },
+    defaultColumnWidth: Il,
+    minColumnWidth: Yo,
+    autoSizeSampleLimit: Xo,
+    autoSizeCharWidth: 7.2,
+    autoSizeHorizontalPadding: 42,
+    autoSizeMaxWidth: 640,
+    isFillDragging: () => _e.value,
+    stopFillSelection: () => {
+      il(!1);
+    },
+    isDragSelecting: () => Ze.value,
+    stopDragSelection: () => {
+      we();
+    },
+    readCellText: (c, y) => {
+      const S = c[y];
+      return S == null ? "" : String(S);
+    }
+  }), Ne = Uo({
+    mode: e.mode,
+    viewportRowStart: N,
+    selectionAnchorCell: ht,
+    fillPreviewRange: ke,
+    isFillDragging: _e,
+    interactionSelectionRange: Tt,
+    resolveCommittedSelectionRange: rt,
+    resolveCommittedSelectionRanges: ot,
+    isCommittedSelectionAnchorCell: Nn,
+    isCommittedCellSelected: tn,
+    shouldHighlightCommittedSelectedCell: Wn,
+    isCommittedCellOnSelectionEdge: nn
+  }), { selectionRange: zt, selectionRanges: vl } = Ne, hl = Lo({
+    lastAppliedFill: ll,
+    selectionRange: zt,
+    isFillDragging: _e
+  }), bl = No({
+    bodyViewportRef: _,
+    isColumnResizing: ml,
+    applyColumnResizeFromPointer: be,
+    stopColumnResize: xn,
+    handleInteractionWindowMouseMove: xe,
+    handleInteractionWindowMouseUp: L,
+    syncViewport: Fe
+  }), H = {
+    rowSelection: ln,
+    history: at,
+    cellIo: Ge,
+    viewportKeyboard: cl,
+    visualSelection: Ne,
+    fillAction: hl,
+    scrollSync: bl
+  }, {
+    tableStageProps: yl,
+    tableStageContext: Mn
+  } = Bo({
+    mode: e.mode,
+    rowHeightMode: e.rowHeightMode,
+    layoutMode: e.layoutMode,
+    chromeSignature: e.chromeSignature,
+    visibleColumns: I,
+    renderedColumns: Bt,
+    displayRows: le,
+    displayRowsRevision: Pn,
+    runtimeRevision: Gt,
+    pinnedBottomRows: se,
+    sourceRows: e.sourceRows ?? e.rows,
+    showRowIndex: i,
+    rowHover: w(() => e.rowHover?.value === !0),
+    stripedRows: w(() => e.stripedRows?.value === !0),
+    columnFilterTextByKey: e.columnFilterTextByKey,
+    gridContentStyle: Bn,
+    mainTrackStyle: jn,
+    indexColumnStyle: rn,
+    stageStyle: wt,
+    bodyShellStyle: We,
+    topSpacerHeight: Tn,
+    bottomSpacerHeight: zn,
+    viewportRowStart: N,
+    viewportRowEnd: tt,
+    virtualRowTotal: R,
+    baseRowHeight: e.normalizedBaseRowHeight,
+    resolveRowHeight: j.resolveRowHeight,
+    resolveRowOffset: j.resolveRowOffset,
+    columnWindowStart: nt,
+    leftColumnSpacerWidth: Hn,
+    rightColumnSpacerWidth: Vn,
+    editingCellValueRef: Le,
+    editingCellInitialFilter: xt,
+    editingCellOpenOnMount: Qn,
+    selectionRange: zt,
+    selectionRanges: vl,
+    selectionAnchorCell: ht,
+    totalRowCount: R,
+    fillPreviewRange: ke,
+    rangeMovePreviewRange: al,
+    customOverlays: yt,
+    reportCenterPaneDiagnostics: Ue,
+    fillHandleEnabled: w(() => e.enableFillHandle.value),
+    rangeMoveEnabled: w(() => e.enableRangeMove.value),
+    isFillDragging: _e,
+    isRangeMoving: rl,
+    headerViewportRef: z,
+    bodyViewportRef: _,
+    columnStyle: Lt,
+    reorderColumnsByHeader: e.reorderColumnsByHeader,
+    toggleSortForColumn: e.toggleSortForColumn,
+    handleHeaderColumnClick: e.handleHeaderColumnClick,
+    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,
+    resolveColumnMenuValueEntries: e.resolveColumnMenuValueEntries,
+    applyColumnMenuSort: e.applyColumnMenuSort,
+    applyColumnMenuPin: e.applyColumnMenuPin,
+    applyColumnMenuGroupBy: e.applyColumnMenuGroupBy,
+    applyColumnMenuFilter: e.applyColumnMenuFilter,
+    clearColumnMenuFilter: e.clearColumnMenuFilter,
+    handleHeaderWheel: H.scrollSync.handleHeaderWheel,
+    handleHeaderScroll: H.scrollSync.handleHeaderScroll,
+    handleViewportScroll: Fe,
+    handleViewportKeydown: H.viewportKeyboard.handleViewportKeydown,
+    rowClass: Xn,
+    isRowAutosizeProbe: Wt,
+    rowStyle: Nt,
+    isRowInPendingClipboardCut: e.isRowInPendingClipboardCut,
+    isRowFocused: H.rowSelection.isRowFocused,
+    isRowCheckboxSelected: H.rowSelection.isRowCheckboxSelected,
+    allVisibleRowsSelected: H.rowSelection.areAllVisibleRowsSelected,
+    someVisibleRowsSelected: H.rowSelection.areSomeVisibleRowsSelected,
+    handleRowClick: H.rowSelection.focusRow,
+    handleRowIndexClick: H.rowSelection.selectRowRange,
+    handleRowIndexKeydown: ie,
+    reorderRowsByIndex: e.reorderRowsByIndex,
+    handleToggleAllVisibleRows: H.rowSelection.toggleVisibleRowsSelected,
+    toggleGroupRow: Ye,
+    rowIndexLabel: on,
+    startResize: fl,
+    handleResizeDoubleClick: wl,
+    startRowResize: Ut,
+    autosizeRow: qt,
+    isCellSelected: H.visualSelection.isCellSelected,
+    isSelectionAnchorCell: H.visualSelection.isSelectionAnchorCell,
+    shouldHighlightSelectedCell: H.visualSelection.shouldHighlightSelectedCell,
+    isCellOnSelectionEdge: H.visualSelection.isCellOnSelectionEdge,
+    isCellInFillPreview: ce,
+    isCellInPendingClipboardRange: fn,
+    isCellOnPendingClipboardEdge: Se,
+    isEditingCell: wn,
+    isCellEditable: (c, y, S, D) => sn(
+      c,
+      S,
+      () => M(c, N.value + y, S)
+    ),
+    handleCellMouseDown: Pt,
+    handleCellClick: H.cellIo.handleCellClick,
+    handleCellKeydown: Sn,
+    startInlineEdit: Mt,
+    isFillHandleCell: In,
+    startFillHandleDrag: pn,
+    startFillHandleDoubleClick: sl,
+    fillActionAnchorCell: H.fillAction.fillActionAnchorCell,
+    fillActionBehavior: H.fillAction.fillActionBehavior,
+    applyFillActionBehavior: ul,
+    handleEditorKeydown: vn,
+    handleEditorBlur: el,
+    commitInlineEdit: Ft,
+    cancelInlineEdit: ut,
+    readCell: H.cellIo.readStageCell,
+    readDisplayCell: H.cellIo.readStageDisplayCell,
+    cellClass: e.cellClass ? (c, y, S, D) => e.cellClass?.(
+      c,
+      N.value + y,
+      S,
+      D
+    ) : void 0,
+    cellStyle: e.cellStyle ? (c, y, S, D) => e.cellStyle?.(
+      c,
+      N.value + y,
+      S,
+      D
+    ) : void 0
+  });
+  return Lr({
+    mode: e.mode,
+    rows: e.rows,
+    runtime: e.runtime,
+    totalRows: R,
+    rowVersion: e.rowVersion,
+    rowHeightMode: e.rowHeightMode,
+    normalizedBaseRowHeight: e.normalizedBaseRowHeight,
+    syncSelectionSnapshotFromRuntime: e.syncSelectionSnapshotFromRuntime,
+    syncRowSelectionSnapshotFromRuntime: l,
+    syncViewport: re,
+    scheduleViewportSync: lt,
+    measureVisibleRowHeights: vt,
+    applyRowHeightSettings: e.applyRowHeightSettings
+  }), $r({
+    bodyViewportRef: _,
+    syncViewport: re,
+    handleWindowMouseMove: H.scrollSync.handleWindowMouseMove,
+    handleWindowMouseUp: H.scrollSync.handleWindowMouseUp,
+    cancelScheduledViewportSync: jt,
+    onAfterMount: () => {
+      e.syncSelectionSnapshotFromRuntime(), l(), et(() => {
+        e.applyRowHeightSettings(), re();
+      });
+    },
+    dispose: [
+      Jt,
+      gl,
+      Ee,
+      H.history.disposeIntentHistory
+    ]
+  }), {
+    tableStageProps: yl,
+    tableStageContext: Mn,
+    historyController: {
+      canUndo: Ot,
+      canRedo: _t,
+      runHistoryAction: kt
+    },
+    syncViewportFromDom: re,
+    copySelectedCells: cn,
+    pasteSelectedCells: mn,
+    cutSelectedCells: It,
+    clearSelectedCells: dl,
+    captureHistorySnapshot: Ae,
+    captureHistorySnapshotForRowIds: Be,
+    recordHistoryIntentTransaction: De,
+    revealCellInComfortZone: st
+  };
+}
+function Dl(e) {
+  return e === "or" ? "or" : "and";
+}
+function jl(e) {
+  return e == null ? "" : e instanceof Date ? e.toISOString() : Array.isArray(e) ? e.map((l) => jl(l)).filter((l) => l.length > 0).join(", ") : String(e);
+}
+function Qo(e) {
+  const l = e.indexOf(":");
+  if (l > 0) {
+    const a = e.slice(0, l);
+    if (/^[a-z-]+$/i.test(a))
+      return e.slice(l + 1);
+  }
+  return e;
+}
+function ea(e) {
+  const l = [];
+  for (const [a, r] of Object.entries(e.columnFilters ?? {})) {
+    if (!r)
+      continue;
+    if (r.kind === "valueSet") {
+      const i = Array.from(new Set(
+        (r.tokens ?? []).map((g) => Qo(String(g ?? ""))).map((g) => g.trim()).filter((g) => g.length > 0)
+      ));
+      if (i.length === 0)
+        continue;
+      l.push({
+        id: l.length,
+        join: "and",
+        columnKey: a,
+        operator: "in",
+        value: i.join(", ")
+      });
+      continue;
+    }
+    const u = [r.value, r.value2].map((i) => jl(i)).filter((i) => i.length > 0);
+    u.length !== 0 && l.push({
+      id: l.length,
+      join: "and",
+      columnKey: a,
+      operator: String(r.operator ?? "contains"),
+      value: u.join(", ")
+    });
+  }
+  return l;
+}
+function mr(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: jl(e.value)
+    }];
+  const l = [];
+  for (let a = 0; a < e.children.length; a += 1) {
+    const r = e.children[a];
+    if (!r)
+      continue;
+    const u = mr(r);
+    if (u.length === 0)
+      continue;
+    const i = u[0];
+    a > 0 && i && (u[0] = {
+      ...i,
+      id: i.id,
+      join: Dl(e.operator)
+    }), l.push(...u);
+  }
+  return l;
+}
+function Jl(e) {
+  if (!e)
+    return [];
+  const l = ea(e), a = e.advancedExpression ?? Ar(e.advancedFilters), r = mr(a ?? null);
+  return [
+    ...l,
+    ...r.map((i, g) => l.length > 0 && g === 0 ? {
+      ...i,
+      join: Dl("and")
+    } : i)
+  ].map((i, g) => ({
+    ...i,
+    id: g,
+    join: g === 0 ? Dl("and") : i.join
+  }));
+}
+const ta = Pl(() => import("./DataGridAdvancedFilterPopover-C_MjEKFo.js")), na = Pl(() => import("./DataGridAggregationsPopover-C8kdwv0O.js")), la = Pl(() => import("./DataGridFindReplacePopover-Dou8Fsm3.js"));
+function ra(e) {
+  return {
+    ...e,
+    component: Cr(pr(e.component))
+  };
+}
+function oa(e, l) {
+  if (!e)
+    return l ?? null;
+  if (!l)
+    return e;
+  const a = {}, r = (u) => {
+    if (typeof u == "string") {
+      for (const i of u.split(/\s+/).filter(Boolean))
+        a[i] = !0;
+      return;
+    }
+    if (Array.isArray(u)) {
+      for (const i of u)
+        if (typeof i == "string")
+          for (const g of i.split(/\s+/).filter(Boolean))
+            a[g] = !0;
+      return;
+    }
+    for (const [i, g] of Object.entries(u))
+      a[i] = g === !0 || a[i] === !0;
+  };
+  return r(e), r(l), Object.keys(a).length > 0 ? a : null;
+}
+function aa(e) {
+  return Number.isFinite(e) ? Math.max(24, Math.trunc(e)) : 31;
+}
+function Xl(e) {
+  return typeof CSS < "u" && typeof CSS.escape == "function" ? CSS.escape(e) : e.replace(/\\/g, "\\\\").replace(/\"/g, '\\"');
+}
+function Zl(e) {
+  return (e ?? []).map((l) => ({
+    key: l.key,
+    direction: l.direction
+  }));
+}
+function Ol() {
+  return {
+    columnFilters: {},
+    advancedFilters: {},
+    advancedExpression: null
+  };
+}
+function ct(e) {
+  return Or(e ?? Ol()) ?? Ol();
+}
+function _l(e) {
+  return e.startsWith("string:") ? `string:${e.slice(7).toLowerCase()}` : e;
+}
+function ia(e) {
+  const l = {};
+  for (const [u, i] of Object.entries(e.columnFilters ?? {})) {
+    if (i.kind === "valueSet") {
+      const g = Array.from(new Set(
+        (i.tokens ?? []).map((h) => _l(String(h ?? ""))).filter((h) => h.length > 0)
+      ));
+      if (g.length === 0)
+        continue;
+      l[u] = {
+        kind: "valueSet",
+        tokens: g
+      };
+      continue;
+    }
+    l[u] = {
+      kind: "predicate",
+      operator: i.operator,
+      value: i.value,
+      value2: i.value2,
+      caseSensitive: i.caseSensitive
+    };
+  }
+  const a = { ...e.advancedFilters ?? {} }, r = e.advancedExpression ?? null;
+  return Object.keys(l).length === 0 && Object.keys(a).length === 0 && !r ? null : {
+    columnFilters: l,
+    advancedFilters: a,
+    advancedExpression: r
+  };
+}
+function sa(e) {
+  const l = {}, a = e?.columnFilters ?? {};
+  for (const [r, u] of Object.entries(a))
+    u?.kind === "predicate" && typeof u.value == "string" && (l[r] = u.value);
+  return l;
+}
+function Ce(e) {
+  if (typeof globalThis.structuredClone == "function")
+    try {
+      return globalThis.structuredClone(e);
+    } catch {
+    }
+  return kl(e, /* @__PURE__ */ new WeakMap());
+}
+function kl(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 a = [];
+    l.set(e, a);
+    for (const r of e)
+      a.push(kl(r, l));
+    return a;
+  }
+  if (fr(e)) {
+    if (l.has(e))
+      return l.get(e);
+    const a = {};
+    l.set(e, a);
+    for (const [r, u] of Object.entries(e))
+      a[r] = kl(u, l);
+    return a;
+  }
+  return e && typeof e == "object" ? { ...e } : e;
+}
+function fr(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const l = Object.getPrototypeOf(e);
+  return l === Object.prototype || l === null;
+}
+function ua(e) {
+  const l = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(e, (a, r) => {
+      if (r == null || typeof r != "object")
+        return r;
+      if (r instanceof Date)
+        return r.toISOString();
+      if (Array.isArray(r) || fr(r))
+        return l.has(r) ? void 0 : (l.add(r), r);
+    });
+  } catch {
+    return null;
+  }
+}
+function Vt(e) {
+  return e ? {
+    columns: e.columns.map((l) => ({ ...l })),
+    basis: e.basis === "source" ? "source" : "filtered"
+  } : null;
+}
+function da(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 Ve(e, l) {
+  return no(l, e);
+}
+function ca(e, l) {
+  const a = String(e ?? "");
+  if (a === "null")
+    return l.blankValueLabel;
+  const r = a.indexOf(":");
+  if (r < 0)
+    return a;
+  const u = a.slice(0, r), i = a.slice(r + 1);
+  return u === "string" || u === "number" || u === "boolean" || u === "bigint" || u === "date" || u === "repr" || u === "json" ? i : a;
+}
+function ma(e, l, a) {
+  return l.kind === "valueSet" ? l.tokens.length === 1 ? `${e}: ${ca(l.tokens[0] ?? "", a)}` : `${e}: ${l.tokens.length} ${a.valuesSummaryLabel}` : l.operator === "between" ? `${e} ${Ve(l.operator, a)} ${He(l.value)} ${a.betweenJoiner} ${He(l.value2)}` : l.operator === "isEmpty" || l.operator === "notEmpty" || l.operator === "isNull" || l.operator === "notNull" ? `${e} ${Ve(l.operator, a)}` : `${e} ${Ve(l.operator, a)} ${He(l.value)}`;
+}
+function fa(e, l, a) {
+  const r = l.clauses.map((u, i) => {
+    const g = u.join === "or" ? a.joins.or : a.joins.and, h = i === 0 ? "" : `${g} `;
+    return u.operator === "between" ? `${h}${Ve(u.operator, a)} ${He(u.value)} ${a.betweenJoiner} ${He(u.value2)}` : u.operator === "isEmpty" || u.operator === "notEmpty" || u.operator === "isNull" || u.operator === "notNull" ? `${h}${Ve(u.operator, a)}` : `${h}${Ve(u.operator, a)} ${He(u.value)}`;
+  }).filter((u) => u.length > 0);
+  return r.length === 0 ? `${e}: ${a.activeSummaryFallback}` : `${e} ${r.join(" ")}`;
+}
+function El(e, l, a) {
+  if (e.kind === "condition") {
+    const u = l(e.key);
+    return e.operator === "between" ? `${u} ${Ve(e.operator, a)} ${He(e.value)} ${a.betweenJoiner} ${He(e.value2)}` : e.operator === "isEmpty" || e.operator === "notEmpty" || e.operator === "isNull" || e.operator === "notNull" ? `${u} ${Ve(e.operator, a)}` : `${u} ${Ve(e.operator, a)} ${He(e.value)}`;
+  }
+  if (e.kind === "not")
+    return `${a.notOperatorLabel} (${El(e.child, l, a)})`;
+  const r = e.operator === "or" ? a.joins.or : a.joins.and;
+  return e.children.map((u) => El(u, l, a)).filter((u) => u.length > 0).join(` ${r} `);
+}
+function Ql(e, l) {
+  return l.activeSummaryPrefix.length > 0 ? `${l.activeSummaryPrefix}: ${e}` : e;
+}
+const wa = [
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count",
+  "countNonNull",
+  "first",
+  "last"
+], ga = [
+  "min",
+  "max",
+  "count",
+  "countNonNull",
+  "first",
+  "last"
+], va = [
+  "count",
+  "countNonNull",
+  "first",
+  "last"
+];
+function ha(e) {
+  return e === "number" || e === "currency" || e === "percent" ? wa : e === "date" || e === "datetime" ? ga : va;
+}
+const ba = {
+  clipboard: ["cut", "copy", "paste"],
+  pasteSpecial: ["paste-values"],
+  edit: ["clear"]
+}, ya = {
+  insert: ["insert-row-above", "insert-row-below"],
+  clipboard: ["cut-row", "copy-row", "paste-row"],
+  selection: ["delete-selected-rows"]
+}, er = {
+  cut: "Cut",
+  copy: "Copy",
+  paste: "Paste",
+  "paste-values": "Values only",
+  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"
+}, Ra = {
+  "insert-row-above": "Insert / Ctrl/Cmd+I",
+  "copy-row": "Ctrl/Cmd+C",
+  "paste-row": "Ctrl/Cmd+V",
+  "cut-row": "Ctrl/Cmd+X"
+}, Wa = kn({
+  name: "DataGridDefaultRenderer",
+  props: {
+    mode: {
+      type: String,
+      required: !0
+    },
+    rows: {
+      type: Array,
+      default: () => []
+    },
+    runtime: {
+      type: Object,
+      required: !0
+    },
+    runtimeRowModel: {
+      type: Object,
+      required: !0
+    },
+    reportFillWarning: {
+      type: Function,
+      default: void 0
+    },
+    reportCenterPaneDiagnostics: {
+      type: Function,
+      default: void 0
+    },
+    reportFillPlumbingState: {
+      type: Function,
+      default: void 0
+    },
+    reportFillPlumbingDetail: {
+      type: Function,
+      default: void 0
+    },
+    selectionSnapshot: {
+      type: Object,
+      required: !0
+    },
+    selectionAnchor: {
+      type: Object,
+      required: !0
+    },
+    rowSelectionSnapshot: {
+      type: Object,
+      required: !0
+    },
+    onCellEdit: {
+      type: Function,
+      default: void 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
+    },
+    columnReorder: {
+      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
+    },
+    placeholderRows: {
+      type: Object,
+      required: !0
+    },
+    fillHandle: {
+      type: Boolean,
+      default: !1
+    },
+    rangeMove: {
+      type: Boolean,
+      default: !1
+    },
+    rowHover: {
+      type: Boolean,
+      default: !1
+    },
+    stripedRows: {
+      type: Boolean,
+      default: !1
+    },
+    readSelectionCell: {
+      type: Function,
+      default: void 0
+    },
+    cellClass: {
+      type: Function,
+      default: void 0
+    },
+    cellStyle: {
+      type: Function,
+      default: void 0
+    },
+    showRowIndex: {
+      type: Boolean,
+      default: !0
+    },
+    rowSelection: {
+      type: Boolean,
+      default: !0
+    },
+    rowReorder: {
+      type: Object,
+      required: !0
+    },
+    isCellEditable: {
+      type: Function,
+      default: void 0
+    },
+    viewMode: {
+      type: String,
+      default: "table"
+    },
+    gantt: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    toolbarModules: {
+      type: Array,
+      default: () => []
+    },
+    customOverlays: {
+      type: Array,
+      default: void 0
+    },
+    history: {
+      type: Object,
+      required: !0
+    },
+    chrome: {
+      type: Object,
+      required: !0
+    },
+    registerHistoryController: {
+      type: Function,
+      default: () => {
+      }
+    },
+    reportToolbarModules: {
+      type: Function,
+      default: () => {
+      }
+    },
+    runStructuralRowAction: {
+      type: Function,
+      default: void 0
+    },
+    registerStructuralRowActionRunner: {
+      type: Function,
+      default: () => {
+      }
+    },
+    inspectorPanel: {
+      type: Object,
+      default: null
+    }
+  },
+  setup(e) {
+    const l = w(() => ({
+      "--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",
+      "--datagrid-app-layout-gap": `${e.chrome.toolbarGap}px`,
+      "--datagrid-app-workspace-gap": `${e.chrome.workspaceGap}px`,
+      "--datagrid-app-toolbar-gap": e.chrome.density === "compact" ? "10px" : "12px",
+      "--datagrid-app-toolbar-group-gap": e.chrome.density === "compact" ? "6px" : "8px",
+      "--datagrid-app-toolbar-button-gap": e.chrome.density === "compact" ? "6px" : "8px",
+      "--datagrid-app-toolbar-button-height": e.chrome.density === "compact" ? "28px" : "32px",
+      "--datagrid-app-toolbar-button-padding-inline": e.chrome.density === "compact" ? "10px" : "12px",
+      "--datagrid-app-toolbar-button-font-size": e.chrome.density === "compact" ? "11px" : "12px",
+      "--datagrid-app-toolbar-surface-padding-block": e.chrome.density === "compact" ? "8px" : "10px",
+      "--datagrid-app-toolbar-surface-padding-inline": e.chrome.density === "compact" ? "10px" : "12px"
+    })), a = w(() => [
+      e.gridLines.body,
+      e.gridLines.header,
+      e.gridLines.pinnedSeparators ? "sep:1" : "sep:0"
+    ].join("|")), r = q(0), u = q(Zl(e.sortModel)), i = q(ct(e.filterModel)), g = w(() => sa(i.value));
+    let h = "";
+    const R = () => {
+      const t = e.runtimeRowModel.getSnapshot();
+      return [
+        t.kind,
+        t.revision ?? "",
+        t.rowCount,
+        t.loading ? 1 : 0,
+        t.projection?.recomputeVersion ?? t.projection?.version ?? ""
+      ].join("|");
+    };
+    h = R();
+    const E = e.runtimeRowModel.subscribe(() => {
+      const t = R();
+      t !== h && (h = t, r.value += 1);
+    });
+    $l(() => {
+      E();
+    }), te(
+      () => e.sortModel,
+      (t) => {
+        u.value = Zl(t);
+      },
+      { deep: !0 }
+    ), te(
+      () => e.filterModel,
+      (t) => {
+        i.value = ct(t);
+      },
+      { deep: !0 }
+    );
+    const O = w(() => e.mode), G = w(() => e.rows), I = w(() => (r.value, e.runtime.api.rows.getSnapshot().rowCount)), b = w(() => e.runtime.columnSnapshot.value.visibleColumns), F = w(() => e.runtime.columnSnapshot.value.columns ?? []), A = w(() => b.value.filter((t) => t.visible !== !1).map((t) => ({
+      key: t.key,
+      label: t.column.label ?? t.key
+    }))), C = w(() => F.value.map((t) => ({
+      key: t.key,
+      label: t.column.label ?? t.key,
+      visible: t.visible !== !1
+    }))), M = w(() => F.value.filter((t) => t.column.capabilities?.aggregatable === !0).map((t) => ({
+      key: t.key,
+      label: t.column.label ?? t.key,
+      allowedOps: ha(t.column.dataType)
+    }))), Y = q(e.rowHeightMode), ne = w(() => aa(e.baseRowHeight)), j = w(() => b.value[0]?.key ?? "name"), Me = w(() => {
+      const t = /* @__PURE__ */ new Map();
+      for (const n of F.value)
+        t.set(n.key, n.column.label ?? n.key);
+      return t;
+    }), {
+      isColumnLayoutPanelOpen: ft,
+      columnLayoutPanelItems: wt,
+      openColumnLayoutPanel: We,
+      cancelColumnLayoutPanel: T,
+      applyColumnLayoutPanel: z,
+      moveColumnUp: _,
+      moveColumnDown: le,
+      moveColumnToPosition: Pn,
+      updateColumnVisibility: gt
+    } = Kr({
+      resolveColumns: () => C.value,
+      applyColumnLayout: (t) => {
+        e.runtime.api.columns.setOrder(t.order);
+        for (const [n, o] of Object.entries(t.visibilityByKey))
+          e.runtime.api.columns.setVisibility(n, o);
+      }
+    }), se = Ml(null), Bt = w(() => se.value?.isAdvancedFilterPanelOpen.value ?? !1), N = w(() => se.value?.advancedFilterDraftClauses.value ?? []), tt = w(() => se.value?.appliedAdvancedFilterExpression.value ?? null), nt = async () => {
+      if (se.value)
+        return se.value;
+      const { useDataGridAppAdvancedFilterBuilder: t } = await import("@affino/datagrid-vue/app"), n = t({
+        resolveColumns: () => A.value
+      });
+      return n.hydrateAdvancedFilterClauses(Jl(i.value)), se.value = n, n;
+    }, Tn = (t) => {
+      se.value?.hydrateAdvancedFilterClauses(t);
+    }, zn = async () => {
+      (await nt()).openAdvancedFilterPanel();
+    }, Hn = async () => {
+      const t = se.value;
+      if (t) {
+        t.addAdvancedFilterClause();
+        return;
+      }
+      (await nt()).addAdvancedFilterClause();
+    }, Vn = async (t) => {
+      const n = se.value;
+      if (n) {
+        n.removeAdvancedFilterClause(t);
+        return;
+      }
+      (await nt()).removeAdvancedFilterClause(t);
+    }, Bn = async (t) => {
+      const n = se.value;
+      if (n) {
+        n.updateAdvancedFilterClause(t);
+        return;
+      }
+      (await nt()).updateAdvancedFilterClause(t);
+    }, jn = () => {
+      se.value?.cancelAdvancedFilterPanel();
+    }, Gn = () => {
+      se.value?.applyAdvancedFilterPanel();
+    }, Ln = () => {
+      se.value?.clearAdvancedFilterPanel();
+    }, Fe = q(!1), J = q(null), re = w(() => !!e.groupBy?.fields?.length), lt = w(() => (r.value, Vt(e.runtime.api.rows.getAggregationModel()))), jt = w(() => (r.value, da(e.runtime.api.rows.getSnapshot().groupBy))), Gt = w(() => {
+      const t = new Map(
+        (J.value?.columns ?? []).map((n) => [n.key, n.op])
+      );
+      return M.value.map((n) => {
+        const o = n.allowedOps[0] ?? "count", s = t.get(n.key), d = s && n.allowedOps.includes(s) ? s : o;
+        return {
+          key: n.key,
+          label: n.label,
+          enabled: t.has(n.key),
+          op: d,
+          allowedOps: n.allowedOps
+        };
+      });
+    }), Ue = w(() => J.value?.basis === "source" ? "source" : "filtered");
+    te(
+      lt,
+      (t) => {
+        Fe.value || (J.value = Vt(t));
+      },
+      { immediate: !0, deep: !0 }
+    ), te(
+      () => e.rowHeightMode,
+      (t) => {
+        Y.value = t;
+      }
+    );
+    const Lt = (t) => {
+      const n = i.value.columnFilters?.[t];
+      return n ? n.kind === "valueSet" ? n.tokens.length > 0 : !0 : !1;
+    }, W = (t) => {
+      const n = i.value.columnFilters?.[t];
+      return !n || n.kind !== "valueSet" ? [] : n.tokens.map((o) => _l(String(o ?? "")));
+    }, $t = (t, n) => e.runtime.api.columns.getHistogram(t, {
+      ignoreSelfFilter: !0,
+      orderBy: "valueAsc",
+      search: n
+    }), Kt = (t) => dr(e.columnMenu, t), Nt = (t) => So(e.columnMenu, t), Wt = (t) => xo(e.columnMenu, t), vt = (t) => Io(e.columnMenu, t), Ut = (t) => Mo(e.columnMenu, t), qt = (t) => Fo(e.columnMenu, t), Yt = (t) => {
+      const n = jt.value?.fields.findIndex((o) => o === t) ?? -1;
+      return n >= 0 ? n : null;
+    }, Jt = (t) => Yt(t) !== null, de = () => {
+      const t = u.value.map((s) => ({
+        key: s.key,
+        direction: s.direction
+      })), n = i.value.advancedExpression ?? null, o = e.advancedFilter.enabled ? {
+        ...i.value,
+        advancedFilters: {},
+        advancedExpression: n
+      } : {
+        ...i.value,
+        advancedExpression: n
+      };
+      e.runtime.api.rows.setSortAndFilterModel({
+        sortModel: t,
+        filterModel: ia(o)
+      });
+    }, Xt = () => {
+      Tn(Jl(i.value));
+    }, Zt = w(() => i.value.advancedExpression ?? null), rt = w(() => {
+      const t = (s) => Me.value.get(s) ?? s, n = e.advancedFilter.labels, o = [];
+      for (const [s, d] of Object.entries(i.value.columnFilters ?? {}))
+        d && o.push(ma(t(s), d, n));
+      for (const [s, d] of Object.entries(i.value.advancedFilters ?? {}))
+        d && o.push(Ql(
+          fa(t(s), d, n),
+          n
+        ));
+      return Zt.value && o.push(Ql(
+        El(Zt.value, t, n),
+        n
+      )), Object.freeze(o);
+    }), ot = w(() => rt.value.length > 0), $n = () => {
+      i.value = Ol(), Ln(), de();
+    };
+    te(
+      i,
+      () => {
+        !e.advancedFilter.enabled || Bt.value || Xt();
+      },
+      { immediate: !0, deep: !0 }
+    );
+    const qe = () => {
+      Xt(), zn();
+    }, Qt = () => {
+      Gn(), i.value = {
+        ...ct(i.value),
+        columnFilters: {},
+        advancedFilters: {},
+        advancedExpression: tt.value
+      }, de();
+    }, Kn = (t, n = !1) => {
+      const o = u.value.findIndex((d) => d.key === t), s = o >= 0 ? u.value[o] : null;
+      if (!s) {
+        const d = { key: t, direction: "asc" };
+        u.value = n ? [...u.value, d] : [d], de();
+        return;
+      }
+      if (s.direction === "asc") {
+        const d = { key: t, direction: "desc" };
+        n ? u.value = u.value.map((v) => v.key === t ? d : v) : u.value = [d], de();
+        return;
+      }
+      u.value = n ? u.value.filter((d) => d.key !== t) : [], de();
+    }, en = (t) => {
+      const n = u.value.findIndex((d) => d.key === t);
+      if (n < 0)
+        return "";
+      const o = u.value[n];
+      if (!o)
+        return "";
+      const s = o.direction === "asc" ? "↑" : "↓";
+      return u.value.length > 1 ? `${s}${n + 1}` : s;
+    }, tn = (t, n) => {
+      const o = ct(i.value), s = n.trim();
+      s ? o.columnFilters[t] = {
+        kind: "predicate",
+        operator: "contains",
+        value: s,
+        caseSensitive: !1
+      } : delete o.columnFilters[t], i.value = o, de();
+    }, Nn = () => {
+      e.runtime.api.view.setRowHeightMode(Y.value), e.runtime.api.view.setBaseRowHeight(ne.value);
+    }, Wn = () => {
+      J.value = Vt(lt.value), Fe.value = !0;
+    }, nn = () => {
+      J.value = Vt(lt.value), Fe.value = !1;
+    };
+    te(
+      re,
+      (t) => {
+        t || nn();
+      },
+      { immediate: !0 }
+    );
+    const ht = () => {
+      J.value = null;
+    }, ln = (t) => {
+      J.value = {
+        basis: t,
+        columns: J.value?.columns ?? []
+      };
+    }, Un = (t, n) => {
+      const o = M.value.find((f) => f.key === t);
+      if (!o)
+        return;
+      const s = J.value?.columns ?? [];
+      if (!n) {
+        const f = s.filter((p) => p.key !== t);
+        J.value = f.length > 0 ? { basis: Ue.value, columns: f } : null;
+        return;
+      }
+      const v = s.find((f) => f.key === t) ?? {
+        key: t,
+        op: o.allowedOps[0] ?? "count"
+      };
+      J.value = {
+        basis: Ue.value,
+        columns: [
+          ...s.filter((f) => f.key !== t),
+          v
+        ]
+      };
+    }, qn = (t, n) => {
+      const o = M.value.find((d) => d.key === t);
+      if (!o || !o.allowedOps.includes(n))
+        return;
+      const s = (J.value?.columns ?? []).map((d) => d.key !== t ? d : {
+        ...d,
+        op: n
+      });
+      J.value = {
+        basis: Ue.value,
+        columns: s
+      };
+    }, Yn = () => {
+      const t = J.value && J.value.columns.length > 0 ? J.value : null;
+      e.runtime.api.rows.setAggregationModel(t), J.value = Vt(t), Fe.value = !1;
+    }, rn = (t) => u.value.find((n) => n.key === t)?.direction ?? null, at = (t, n) => {
+      const o = b.value.find((s) => s.key === t);
+      !o || o.column.capabilities?.sortable === !1 || (u.value = n === null ? u.value.filter((s) => s.key !== t) : [{ key: t, direction: n }], de());
+    }, Ae = (t, n) => {
+      e.runtime.api.columns.setPin(t, n);
+    }, Be = (t, n) => {
+      const o = jt.value, s = n ? Array.from(/* @__PURE__ */ new Set([...o?.fields ?? [], t])) : (o?.fields ?? []).filter((d) => d !== t);
+      e.runtime.api.rows.setGroupBy(s.length > 0 ? {
+        fields: s,
+        expandedByDefault: o?.expandedByDefault ?? !0
+      } : null);
+    }, De = (t, n) => {
+      const o = Array.from(new Set(
+        n.map((d) => _l(String(d ?? ""))).filter((d) => d.length > 0)
+      ));
+      if (o.length === 0) {
+        bt(t);
+        return;
+      }
+      const s = ct(i.value);
+      s.columnFilters[t] = {
+        kind: "valueSet",
+        tokens: o
+      }, i.value = s, de();
+    }, bt = (t) => {
+      const n = ct(i.value);
+      delete n.columnFilters[t], i.value = n, de();
+    }, pe = q(null), ae = q(null);
+    let je = 0;
+    const ve = () => {
+      const t = e.selectionSnapshot.value, n = t?.ranges[t.activeRangeIndex] ?? null;
+      return n ? {
+        startRow: n.startRow,
+        endRow: n.endRow,
+        startColumn: n.startCol,
+        endColumn: n.endCol
+      } : null;
+    }, yt = () => {
+      const t = e.selectionSnapshot.value?.activeCell;
+      return t ? {
+        rowIndex: t.rowIndex,
+        columnIndex: t.colIndex
+      } : null;
+    }, on = (t) => t ? t.startRow !== t.endRow || t.startColumn !== t.endColumn : !1, an = (t, n) => t.rowIndex >= Math.min(n.startRow, n.endRow) && t.rowIndex <= Math.max(n.startRow, n.endRow) && t.columnIndex >= Math.min(n.startColumn, n.endColumn) && t.columnIndex <= Math.max(n.startColumn, n.endColumn), Jn = (t, n) => {
+      const o = e.runtime.resolveBodyRowIndexById(t), s = b.value.findIndex((d) => d.key === n);
+      return o < 0 || s < 0 ? null : { rowIndex: o, columnIndex: s };
+    }, Xn = (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
+      }
+    }), Ye = (t, n) => {
+      if (!Number.isFinite(n))
+        return null;
+      const o = Math.trunc(n);
+      return t[o] ?? null;
+    }, Ge = (t) => typeof t == "string" || typeof t == "number" ? t : null, Rt = () => {
+      const t = e.selectionSnapshot.value, n = b.value.map((d) => d.key);
+      if (!t || n.length === 0)
+        return null;
+      const o = t.ranges.map((d) => {
+        const v = Ye(n, d.startCol), f = Ye(n, d.endCol);
+        if (!v || !f)
+          return null;
+        const p = Ye(n, d.anchor?.colIndex ?? d.startCol) ?? v, x = Ye(n, d.focus?.colIndex ?? d.endCol) ?? f;
+        return {
+          startRow: d.startRow,
+          endRow: d.endRow,
+          startColumnKey: v,
+          endColumnKey: f,
+          startRowId: Ge(d.startRowId),
+          endRowId: Ge(d.endRowId),
+          anchor: {
+            rowIndex: d.anchor?.rowIndex ?? d.startRow,
+            rowId: Ge(d.anchor?.rowId),
+            columnKey: p
+          },
+          focus: {
+            rowIndex: d.focus?.rowIndex ?? d.endRow,
+            rowId: Ge(d.focus?.rowId),
+            columnKey: x
+          }
+        };
+      }).filter((d) => d != null);
+      if (o.length === 0)
+        return null;
+      const s = t.activeCell ? Ye(n, t.activeCell.colIndex) : null;
+      return {
+        ranges: o,
+        activeRangeIndex: Math.max(0, Math.trunc(t.activeRangeIndex ?? 0)),
+        activeCell: t.activeCell && s ? {
+          rowIndex: t.activeCell.rowIndex,
+          rowId: Ge(t.activeCell.rowId),
+          columnKey: s
+        } : null
+      };
+    }, sn = (t) => {
+      const n = b.value.map((f) => f.key);
+      if (n.length === 0)
+        return null;
+      const o = [];
+      for (const f of t.ranges) {
+        const p = n.indexOf(f.startColumnKey), x = n.indexOf(f.endColumnKey), P = n.indexOf(f.anchor.columnKey), k = n.indexOf(f.focus.columnKey);
+        p < 0 || x < 0 || P < 0 || k < 0 || o.push({
+          startRow: f.startRow,
+          endRow: f.endRow,
+          startCol: p,
+          endCol: x,
+          startRowId: f.startRowId,
+          endRowId: f.endRowId,
+          anchor: {
+            rowIndex: f.anchor.rowIndex,
+            colIndex: P,
+            rowId: f.anchor.rowId
+          },
+          focus: {
+            rowIndex: f.focus.rowIndex,
+            colIndex: k,
+            rowId: f.focus.rowId
+          }
+        });
+      }
+      if (o.length === 0)
+        return null;
+      const s = Math.min(o.length - 1, Math.max(0, t.activeRangeIndex)), d = o[s] ?? o[0] ?? null;
+      if (!d)
+        return null;
+      const v = t.activeCell ? n.indexOf(t.activeCell.columnKey) : -1;
+      return {
+        ranges: o,
+        activeRangeIndex: s,
+        activeCell: v >= 0 && t.activeCell ? {
+          rowIndex: t.activeCell.rowIndex,
+          colIndex: v,
+          rowId: t.activeCell.rowId
+        } : {
+          rowIndex: d.focus.rowIndex,
+          colIndex: d.focus.colIndex,
+          rowId: d.focus.rowId
+        }
+      };
+    }, Ct = (t) => {
+      const n = t ? sn(t) : null;
+      n && (e.runtime.api.selection.setSnapshot(n), e.syncSelectionSnapshotFromRuntime()), un();
+    }, Zn = (t) => {
+      if (t.length === 0)
+        return null;
+      const n = new Set(t), o = e.selectionSnapshot.value?.activeCell?.rowId;
+      if (o != null) {
+        const f = String(o);
+        if (n.has(f))
+          return f;
+      }
+      const d = (e.selectionSnapshot.value?.ranges[e.selectionSnapshot.value?.activeRangeIndex ?? 0] ?? null)?.anchor?.rowId;
+      if (d != null) {
+        const f = String(d);
+        if (n.has(f))
+          return f;
+      }
+      const v = e.rowSelectionSnapshot.value?.focusedRow;
+      if (v != null) {
+        const f = String(v);
+        if (n.has(f))
+          return f;
+      }
+      return t[0] ?? null;
+    }, pt = (t, n) => {
+      const o = b.value.length - 1;
+      if (t.length === 0 || o < 0)
+        return null;
+      const s = t.map((p) => ({ rowId: p, rowIndex: e.runtime.resolveBodyRowIndexById(p) })).filter((p) => p.rowIndex >= 0).sort((p, x) => p.rowIndex - x.rowIndex);
+      if (s.length === 0)
+        return null;
+      const d = s[0] ?? null, v = e.runtime.resolveBodyRowIndexById(n), f = v >= 0 ? { rowId: n, rowIndex: v } : d;
+      return !f || f.rowIndex < 0 ? null : {
+        ranges: [{
+          startRow: s[0]?.rowIndex ?? f.rowIndex,
+          endRow: s[s.length - 1]?.rowIndex ?? f.rowIndex,
+          startCol: 0,
+          endCol: o,
+          anchor: {
+            rowIndex: f.rowIndex,
+            colIndex: 0,
+            rowId: f.rowId
+          },
+          focus: {
+            rowIndex: f.rowIndex,
+            colIndex: 0,
+            rowId: f.rowId
+          },
+          startRowId: s[0]?.rowId ?? f.rowId,
+          endRowId: s[s.length - 1]?.rowId ?? f.rowId
+        }],
+        activeRangeIndex: 0,
+        activeCell: {
+          rowIndex: f.rowIndex,
+          colIndex: 0,
+          rowId: f.rowId
+        }
+      };
+    }, un = () => {
+      const t = () => {
+        const o = pe.value?.querySelector(".grid-body-viewport");
+        if (!o)
+          return !1;
+        try {
+          o.focus({ preventScroll: !0 });
+        } catch {
+          o.focus();
+        }
+        return document.activeElement === o;
+      }, n = (o) => {
+        et(() => {
+          if (!(t() || o >= 3)) {
+            if (typeof window < "u") {
+              window.requestAnimationFrame(() => {
+                n(o + 1);
+              });
+              return;
+            }
+            n(o + 1);
+          }
+        });
+      };
+      n(0);
+    }, dn = (t) => {
+      const n = Zn(t);
+      if (!n)
+        return;
+      e.runtime.api.rowSelection.hasSupport() && (e.runtime.api.rowSelection.setFocusedRow(n), e.syncRowSelectionSnapshotFromRuntime?.(), e.flushRowSelectionSnapshotUpdates?.());
+      const o = pt(t, n);
+      o && (e.runtime.api.selection.setSnapshot(o), e.syncSelectionSnapshotFromRuntime()), un();
+    }, it = (t) => {
+      const n = e.runtime.api.rows.getCount();
+      for (let o = 0; o < n; o += 1) {
+        const s = e.runtime.api.rows.get(o);
+        if (s && String(s.rowId) === t)
+          return s;
+      }
+      return null;
+    }, St = (t) => {
+      if (!e.placeholderRows.enabled || !e.placeholderRows.createRowAt || it(t))
+        return null;
+      const n = `.datagrid-stage__row-index-cell[data-row-id="${Xl(t)}"]`, o = pe.value?.querySelector(n), s = Number.parseInt(o?.dataset.rowIndex ?? "", 10);
+      if (!Number.isFinite(s))
+        return null;
+      const d = Math.max(0, Math.trunc(s));
+      return d < e.runtime.api.rows.getCount() ? null : d;
+    }, cn = async (t) => {
+      try {
+        return globalThis.navigator?.clipboard?.writeText ? (await globalThis.navigator.clipboard.writeText(t), !0) : !1;
+      } catch {
+        return !1;
+      }
+    }, mn = async () => {
+      try {
+        return globalThis.navigator?.clipboard?.readText ? await globalThis.navigator.clipboard.readText() : "";
+      } catch {
+        return "";
+      }
+    }, It = async () => {
+      if (ae.value?.rows.length)
+        return ae.value.rows.map((n) => Ce(n));
+      const t = (await mn()).trim();
+      if (!t)
+        return null;
+      try {
+        const n = JSON.parse(t);
+        if (Array.isArray(n))
+          return n.filter((o) => !!o && typeof o == "object").map((o) => Ce(o));
+        if (n && typeof n == "object")
+          return [Ce(n)];
+      } catch {
+        return null;
+      }
+      return null;
+    }, fn = async (t, n, o = []) => {
+      const s = t.map((v) => Ce(v));
+      ae.value = {
+        rows: s,
+        operation: n,
+        sourceRowIds: o.map((v) => String(v))
+      };
+      const d = ua(s);
+      return d && await cn(d), !0;
+    }, Se = () => e.runtime.api.rows.hasInsertSupport(), Oe = () => e.runtime.api.rows.hasDataMutationSupport(), st = (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, he = (t) => {
+      const n = t;
+      return n.rowId != null ? String(n.rowId) : n.id != null ? String(n.id) : null;
+    }, Le = (t) => {
+      for (const n of e.rows) {
+        if (!n || typeof n != "object")
+          continue;
+        const o = n;
+        if ((o.rowId != null ? String(o.rowId) : o.rowKey != null ? String(o.rowKey) : null) === t && st(o))
+          return o;
+      }
+      for (const n of e.rows) {
+        if (!n || typeof n != "object")
+          continue;
+        const o = n;
+        if (st(o))
+          return o;
+      }
+      return null;
+    }, xt = () => (je += 1, `datagrid-row-${Date.now()}-${je}`), Qn = (t) => {
+      const n = Ce(t), o = xt();
+      let s = !1;
+      return "id" in n && (n.id = o, s = !0), "rowId" in n && (n.rowId = o, s = !0), s || (n.id = o), n;
+    }, wn = (t) => {
+      const n = xt(), o = {};
+      for (const [s, d] of Object.entries(t)) {
+        if (s === "id" || s === "rowId") {
+          o[s] = n;
+          continue;
+        }
+        o[s] = typeof d == "number" ? null : "";
+      }
+      return !("id" in o) && !("rowId" in o) && (o.id = n), o;
+    }, Mt = (t, n, o) => {
+      const s = xt(), d = o === "clone" ? Ce(t) : Object.entries(t).reduce((f, [p, x]) => (f[p] = typeof x == "number" ? null : "", f), {});
+      ("id" in d || !("rowId" in d) && !("id" in d)) && (d.id = s), "rowId" in d && (d.rowId = s), "rowKey" in d && (d.rowKey = s);
+      const v = typeof n.state == "object" && n.state != null ? n.state : null;
+      return {
+        kind: n.kind === "group" ? "leaf" : n.kind ?? "leaf",
+        rowId: s,
+        rowKey: s,
+        state: {
+          ...v ?? {},
+          selected: !1,
+          group: !1,
+          pinned: "none",
+          expanded: !1
+        },
+        data: d,
+        row: Ce(d)
+      };
+    }, gn = (t, n = null) => n && st(n) ? Mt(t, n, "clone") : Qn(t), Ft = (t, n = null) => n && st(n) ? Mt(t, n, "blank") : wn(t), ut = (t, n, o) => {
+      if (!e.placeholderRows.enabled || !e.placeholderRows.createRowAt)
+        return null;
+      const s = e.placeholderRows.createRowAt({
+        visualRowIndex: t,
+        materializedRowCount: n,
+        sourceRows: o,
+        reason: "edit"
+      });
+      return s ? Ce(s) : null;
+    }, vn = (t, n) => {
+      if (!Se())
+        return !1;
+      const o = Ie().map((f) => Ce(f));
+      let s = e.runtime.api.rows.getCount();
+      for (; s < n; ) {
+        const f = ut(
+          s,
+          s,
+          o
+        );
+        if (!f || !e.runtime.api.rows.insertDataAt(s, [f]))
+          return !1;
+        o.push(f), s += 1;
+      }
+      const d = Math.max(0, Math.min(s, Math.trunc(t))), v = ut(
+        d,
+        s,
+        o
+      );
+      return v ? e.runtime.api.rows.insertDataAt(d, [v]) : !1;
+    }, el = (t) => {
+      if (!Se())
+        return null;
+      const n = Ie().map((d) => Ce(d));
+      let o = e.runtime.api.rows.getCount();
+      const s = Math.max(0, Math.trunc(t));
+      for (; o < s; ) {
+        const d = ut(
+          o,
+          o,
+          n
+        );
+        if (!d || !e.runtime.api.rows.insertDataAt(o, [d]))
+          return null;
+        n.push(d), o += 1;
+      }
+      return n;
+    }, Je = (t) => {
+      const n = (f) => {
+        const p = e.runtime.resolveBodyRowIndexById(f);
+        if (p < 0 || p >= e.runtime.api.rows.getCount())
+          return !1;
+        const x = e.runtime.getBodyRowAtIndex(p);
+        return x != null && x.kind !== "group" && !Jr(x);
+      }, s = (e.rowSelectionSnapshot.value?.selectedRows ?? []).map((f) => String(f)).filter((f) => f.length > 0 && n(f));
+      if (s.length > 0)
+        return s;
+      const d = ve(), v = b.value.length - 1;
+      if (d && v >= 0) {
+        const f = Math.min(d.startColumn, d.endColumn), p = Math.max(d.startColumn, d.endColumn), x = Math.min(d.startRow, d.endRow), P = Math.max(d.startRow, d.endRow), k = t.length > 0 ? e.runtime.resolveBodyRowIndexById(t) : -1;
+        if (f === 0 && p === v && (k < 0 || k >= x && k <= P)) {
+          const K = [];
+          for (let Z = x; Z <= P; Z += 1) {
+            const me = e.runtime.getBodyRowAtIndex(Z);
+            if (!me || me.kind === "group" || me.rowId == null)
+              continue;
+            const Re = String(me.rowId);
+            n(Re) && K.push(Re);
+          }
+          if (K.length > 0)
+            return K;
+        }
+      }
+      return t.length > 0 && n(t) ? [t] : [];
+    }, Ie = () => {
+      const t = [], n = e.runtime.api.rows.getCount();
+      for (let o = 0; o < n; o += 1) {
+        const s = e.runtime.api.rows.get(o);
+        !s || s.kind === "group" || t.push(s.data);
+      }
+      return t;
+    }, $e = (t) => {
+      const n = new Set(
+        Ie().map((o) => he(o)).filter((o) => o != null)
+      );
+      return Array.from(new Set(t.map((o) => String(o)).filter((o) => n.has(o))));
+    }, hn = (t) => {
+      if (t.length === 0)
+        return [];
+      const n = new Set(t.map((o) => String(o)));
+      return Ie().filter((o) => {
+        const s = he(o);
+        return s != null && n.has(s);
+      });
+    }, Xe = (t) => {
+      if (!Oe() || t.length === 0)
+        return !1;
+      const n = new Set(t), o = Ie().filter((s) => {
+        const d = he(s);
+        return d == null || !n.has(d);
+      });
+      return o.length === e.runtime.api.rows.getCount() ? !1 : (e.runtime.api.rows.replaceData(o), e.runtime.api.rowSelection.hasSupport() && (e.runtime.api.rowSelection.clearSelectedRows(), e.syncRowSelectionSnapshotFromRuntime?.()), !0);
+    }, At = (t, n) => {
+      if (!Oe() || t.length === 0)
+        return !1;
+      const o = Ie(), s = new Set(t.map((p) => String(p))), d = o.filter((p) => {
+        const x = he(p);
+        return x != null && s.has(x);
+      });
+      if (d.length === 0)
+        return !1;
+      const v = o.filter((p) => {
+        const x = he(p);
+        return x == null || !s.has(x);
+      }), f = Number.isFinite(n) ? Math.max(0, Math.min(v.length, Math.trunc(n))) : v.length;
+      return e.runtime.api.rows.replaceData([
+        ...v.slice(0, f),
+        ...d,
+        ...v.slice(f)
+      ]), e.runtime.api.rowSelection.hasSupport() && (e.runtime.api.rowSelection.selectRows(t), e.syncRowSelectionSnapshotFromRuntime?.()), !0;
+    }, tl = (t, n) => {
+      if (!Oe() || t.length === 0 || !n)
+        return !1;
+      const o = new Set(t.map((f) => String(f)));
+      if (o.has(String(n)))
+        return !1;
+      const v = Ie().filter((f) => {
+        const p = he(f);
+        return p == null || !o.has(p);
+      }).findIndex((f) => he(f) === n);
+      return v < 0 ? !1 : At(t, v + 1);
+    }, bn = (t) => {
+      if (!Oe())
+        return !1;
+      const n = String(t.sourceRowId), o = String(t.targetRowId);
+      if (!n || !o || n === o)
+        return !1;
+      const s = $e(Je(n)), d = s.includes(n) ? s : $e([n]);
+      if (d.length === 0 || d.includes(o))
+        return !1;
+      const v = Ie(), f = new Set(d), x = v.filter((K) => {
+        const Z = he(K);
+        return Z == null || !f.has(Z);
+      }).findIndex((K) => he(K) === o);
+      if (x < 0)
+        return !1;
+      const P = we(), k = At(
+        d,
+        t.placement === "after" ? x + 1 : x
+      );
+      return k && (dn(d), be(P, d.length > 1 ? `Move ${d.length} rows` : "Move row")), k;
+    }, Dt = (t) => {
+      const n = String(t.sourceColumnKey), o = String(t.targetColumnKey);
+      if (!n || !o || n === o)
+        return !1;
+      const s = F.value, d = s.find((Q) => Q.key === n), v = s.find((Q) => Q.key === o);
+      if (!d || !v)
+        return !1;
+      const f = s.map((Q) => Q.key), p = f.indexOf(n), x = f.indexOf(o);
+      if (p < 0 || x < 0)
+        return !1;
+      const P = f[p];
+      if (!P)
+        return !1;
+      f.splice(p, 1);
+      const k = f.indexOf(o);
+      if (k < 0)
+        return !1;
+      const K = t.placement === "after" ? k + 1 : k;
+      f.splice(K, 0, P);
+      const Z = Rt(), me = v.pin ?? "none";
+      return (d.pin ?? "none") !== me && e.runtime.api.columns.setPin(n, me), e.runtime.api.columns.setOrder(f), Ct(Z), !0;
+    }, Ke = () => ae.value ? (ae.value = null, !0) : !1, yn = (t) => {
+      if (t.kind === "group")
+        return !1;
+      const n = ae.value;
+      return n ? n.sourceRowIds.includes(String(t.rowId)) : !1;
+    }, Rn = () => typeof e.runStructuralRowAction == "function";
+    let Ot = () => !1, _t = () => {
+    }, kt = () => {
+    };
+    const Cn = q(null);
+    let Et = async (t, n) => !1;
+    const nl = (t, n) => {
+      if (n)
+        return n;
+      const o = er[t], s = Ra[t];
+      return s ? `${o} (${s})` : o;
+    }, {
+      tableStageProps: Ze,
+      tableStageContext: _e,
+      historyController: ke,
+      copySelectedCells: ll,
+      pasteSelectedCells: rl,
+      cutSelectedCells: ol,
+      clearSelectedCells: al,
+      captureHistorySnapshot: we,
+      captureHistorySnapshotForRowIds: il,
+      recordHistoryIntentTransaction: pn,
+      revealCellInComfortZone: sl
+    } = Zo({
+      mode: O,
+      layoutMode: w(() => e.layoutMode),
+      minRows: w(() => e.minRows),
+      maxRows: w(() => e.maxRows),
+      placeholderRows: w(() => e.placeholderRows),
+      enableFillHandle: w(() => e.fillHandle),
+      enableRangeMove: w(() => e.rangeMove),
+      rows: G,
+      sourceRows: G,
+      runtime: e.runtime,
+      runtimeRowModel: e.runtimeRowModel ?? null,
+      rowVersion: r,
+      totalRuntimeRows: I,
+      visibleColumns: b,
+      rowRenderMode: w(() => e.renderMode),
+      rowHeightMode: Y,
+      normalizedBaseRowHeight: ne,
+      selectionSnapshot: e.selectionSnapshot,
+      selectionAnchor: e.selectionAnchor,
+      rowSelectionSnapshot: e.rowSelectionSnapshot,
+      rowHover: w(() => e.rowHover),
+      stripedRows: w(() => e.stripedRows),
+      chromeSignature: a,
+      onCellEdit: e.onCellEdit,
+      showRowIndex: w(() => e.showRowIndex),
+      showRowSelection: w(() => e.rowSelection),
+      isRowInPendingClipboardCut: yn,
+      syncSelectionSnapshotFromRuntime: e.syncSelectionSnapshotFromRuntime,
+      syncRowSelectionSnapshotFromRuntime: e.syncRowSelectionSnapshotFromRuntime,
+      flushRowSelectionSnapshotUpdates: e.flushRowSelectionSnapshotUpdates,
+      clearExternalPendingClipboardOperation: Ke,
+      reportFillWarning: e.reportFillWarning,
+      reportCenterPaneDiagnostics: e.reportCenterPaneDiagnostics,
+      reportFillPlumbingState: e.reportFillPlumbingState,
+      reportFillPlumbingDetail: e.reportFillPlumbingDetail,
+      firstColumnKey: j,
+      columnFilterTextByKey: g,
+      virtualization: w(() => e.virtualization),
+      toggleSortForColumn: Kn,
+      sortIndicator: en,
+      setColumnFilterText: tn,
+      columnMenuEnabled: w(() => e.columnMenu.enabled),
+      columnMenuTrigger: w(() => e.columnMenu.trigger),
+      columnMenuMaxFilterValues: w(() => e.columnMenu.maxFilterValues),
+      resolveColumnMenuItems: Kt,
+      resolveColumnMenuDisabledItems: Nt,
+      resolveColumnMenuDisabledReasons: Wt,
+      resolveColumnMenuLabels: vt,
+      resolveColumnMenuActionOptions: Ut,
+      resolveColumnMenuCustomItems: qt,
+      isColumnFilterActive: Lt,
+      isColumnGrouped: Jt,
+      resolveColumnGroupOrder: Yt,
+      resolveColumnMenuSortDirection: rn,
+      resolveColumnMenuSelectedTokens: W,
+      resolveColumnMenuValueEntries: $t,
+      applyColumnMenuSort: at,
+      applyColumnMenuPin: Ae,
+      applyColumnMenuGroupBy: Be,
+      applyColumnMenuFilter: De,
+      clearColumnMenuFilter: bt,
+      applyRowHeightSettings: Nn,
+      cloneRowData: Ce,
+      readSelectionCell: e.readSelectionCell,
+      historyEnabled: w(() => e.history.enabled),
+      historyMaxDepth: w(() => e.history.depth),
+      historyShortcuts: w(() => e.history.shortcuts),
+      history: e.history.adapter,
+      isCellEditable: e.isCellEditable,
+      isContextMenuVisible: () => Ot(),
+      closeContextMenu: () => _t(),
+      openContextMenuFromCurrentCell: () => {
+        kt();
+      },
+      runRowIndexKeyboardAction: (t, n) => Et(t, n),
+      reorderColumnsByHeader: e.columnReorder.enabled ? Dt : void 0,
+      reorderRowsByIndex: e.rowReorder.enabled ? bn : void 0,
+      cellClass: (t, n, o, s) => {
+        const d = Cn.value, v = !d || t.kind === "group" || t.rowId == null || t.rowId !== d.rowId || o.key !== d.columnKey ? null : {
+          "grid-cell--find-match-active": !0,
+          "grid-cell--find-match-flash-a": d.flashPhase === 0,
+          "grid-cell--find-match-flash-b": d.flashPhase === 1
+        };
+        return oa(
+          v,
+          e.cellClass?.(t, n, o, s)
+        );
+      },
+      cellStyle: e.cellStyle
+    });
+    te(
+      () => e.registerHistoryController,
+      (t) => {
+        t?.(ke);
+      },
+      { immediate: !0 }
+    ), te(
+      () => e.registerStructuralRowActionRunner,
+      (t) => {
+        t?.(xn);
+      },
+      { immediate: !0 }
+    ), te(
+      () => e.history.shortcuts,
+      (t, n, o) => {
+        if (t !== "window" || typeof window > "u")
+          return;
+        const s = (d) => {
+          if (d.defaultPrevented || d.altKey || !(d.ctrlKey || d.metaKey))
+            return;
+          const v = d.key.toLowerCase(), f = v === "z" ? d.shiftKey ? "redo" : "undo" : v === "y" && !d.shiftKey ? "redo" : null;
+          f && (d.preventDefault(), ke.runHistoryAction(f));
+        };
+        window.addEventListener("keydown", s), o(() => {
+          window.removeEventListener("keydown", s);
+        });
+      },
+      { immediate: !0 }
+    ), $l(() => {
+      e.registerHistoryController?.(null), e.registerStructuralRowActionRunner?.(null);
+    });
+    const ul = w(() => Ze.value.columns.visibleColumns), Pt = (t) => {
+      e.runtime.api.selection.setSnapshot(Xn(t)), e.syncSelectionSnapshotFromRuntime();
+    }, Sn = (t, n, o, s) => t.kind === "group" || t.rowId == null || o.column.capabilities?.editable === !1 ? !1 : e.isCellEditable ? e.isCellEditable({
+      row: t.data,
+      rowId: t.rowId,
+      rowIndex: n,
+      column: o.column,
+      columnKey: o.key
+    }) : !0, ie = Ml(null), xe = async () => {
+      if (ie.value)
+        return ie.value;
+      const { useDataGridAppFindReplace: t } = await import("./useDataGridAppFindReplace-DTSLds4f.js"), n = t({
+        runtime: e.runtime,
+        visibleColumns: b,
+        stageVisibleColumns: ul,
+        resolveCurrentCellCoord: yt,
+        applyActiveCell: Pt,
+        revealCellInComfortZone: sl,
+        captureRowsSnapshot: we,
+        captureRowsSnapshotForRowIds: il,
+        recordHistoryIntentTransaction: pn,
+        isCellEditable: Sn
+      });
+      return ie.value = n, n;
+    }, L = {
+      isPanelOpen: w(() => ie.value?.isPanelOpen.value ?? !1),
+      findText: w(() => ie.value?.findText.value ?? ""),
+      replaceText: w(() => ie.value?.replaceText.value ?? ""),
+      matchCase: w(() => ie.value?.matchCase.value ?? !1),
+      statusText: w(() => ie.value?.statusText.value ?? ""),
+      active: w(() => ie.value?.active.value ?? !1),
+      canFind: w(() => ie.value?.canFind.value ?? !1),
+      canReplaceCurrent: w(() => ie.value?.canReplaceCurrent.value ?? !1),
+      canReplaceAll: w(() => ie.value?.canReplaceAll.value ?? !1),
+      highlightedCell: w(() => ie.value?.highlightedCell.value ?? null),
+      openPanel: async () => {
+        (await xe()).openPanel();
+      },
+      closePanel: () => {
+        ie.value?.closePanel();
+      },
+      updateFindText: async (t) => {
+        (await xe()).updateFindText(t);
+      },
+      updateReplaceText: async (t) => {
+        (await xe()).updateReplaceText(t);
+      },
+      updateMatchCase: async (t) => {
+        (await xe()).updateMatchCase(t);
+      },
+      findNext: async () => (await xe()).findNext(),
+      findPrevious: async () => (await xe()).findPrevious(),
+      replaceCurrent: async () => (await xe()).replaceCurrent(),
+      replaceAll: async () => (await xe()).replaceAll()
+    };
+    te(
+      () => L.highlightedCell.value,
+      (t) => {
+        Cn.value = t;
+      },
+      { immediate: !0 }
+    );
+    const {
+      contextMenu: ce,
+      contextMenuRef: In,
+      contextMenuStyle: dl,
+      closeContextMenu: Ee,
+      openContextMenu: Tt,
+      onContextMenuKeyDown: cl
+    } = Dr();
+    Ot = () => ce.value.visible, _t = Ee;
+    const ml = Nr({
+      isInteractionBlocked: () => !1,
+      isRangeMoveModifierActive: () => !1,
+      resolveSelectionRange: ve,
+      resolveCellCoordFromDataset: Jn,
+      applyCellSelection: (t) => {
+        Pt(t);
+      },
+      resolveActiveCellCoord: yt,
+      setActiveCellCoord: (t) => {
+        Pt(t);
+      },
+      cellCoordsEqual: (t, n) => t?.rowIndex === n?.rowIndex && t?.columnIndex === n?.columnIndex,
+      isMultiCellSelection: on,
+      isCoordInsideRange: an,
+      openContextMenu: Tt,
+      closeContextMenu: Ee,
+      isColumnContextEnabled: (t) => e.cellMenu.enabled ? On(e.cellMenu, t).length > 0 : !1,
+      isRowIndexContextEnabled: () => e.rowIndexMenu.enabled && e.showRowIndex
+    }), fl = Wr({
+      resolveCurrentCellCoord: yt,
+      resolveViewportElement: () => pe.value,
+      resolveRowAtIndex: (t) => e.runtime.getBodyRowAtIndex(t) ?? void 0,
+      resolveColumnAtIndex: (t) => b.value[t] ?? void 0,
+      resolveSelectionRange: ve,
+      isMultiCellSelection: (t) => on(t),
+      isCoordInsideRange: an,
+      openContextMenu: Tt,
+      isColumnContextEnabled: (t) => e.cellMenu.enabled && On(e.cellMenu, t.key).length > 0
+    });
+    kt = () => {
+      fl.openContextMenuFromCurrentCell();
+    };
+    const wl = (t) => {
+      if (!e.rowIndexMenu.enabled || !e.showRowIndex || !pe.value)
+        return !1;
+      const n = String(t), o = `.datagrid-stage__row-index-cell[data-row-id="${Xl(n)}"]`, s = pe.value.querySelector(o);
+      if (!s)
+        return !1;
+      const d = s.getBoundingClientRect();
+      return Tt(
+        d.left + Math.max(10, Math.min(d.width / 2, Math.max(10, d.width - 10))),
+        d.bottom - 4,
+        {
+          zone: "row-index",
+          rowId: n
+        }
+      ), !0;
+    }, be = (t, n) => {
+      pn({
+        intent: "edit",
+        label: n
+      }, t);
+    };
+    async function xn(t, n) {
+      const o = String(n), s = St(o), d = s == null ? it(o) : null, v = $e(Je(o)), f = await e.runStructuralRowAction?.({
+        action: t,
+        rowId: n,
+        row: d && d.kind !== "group" ? d : null,
+        rowIndex: s ?? e.runtime.resolveBodyRowIndexById(o),
+        placeholderVisualRowIndex: s,
+        selectedRowIds: v
+      });
+      if (typeof f == "boolean")
+        return f;
+      if (s != null) {
+        if (t === "delete-selected-rows") {
+          if (v.length === 0)
+            return !1;
+          const p = we(), x = Xe(v);
+          return x && be(p, v.length > 1 ? `Delete ${v.length} rows` : "Delete row"), x;
+        }
+        if (t === "insert-row-above") {
+          const p = we(), x = vn(
+            s,
+            s
+          );
+          return x && be(p, "Insert row above"), x;
+        }
+        if (t === "insert-row-below") {
+          const p = we(), x = vn(
+            s + 1,
+            s + 1
+          );
+          return x && be(p, "Insert row below"), x;
+        }
+        return !1;
+      }
+      if (!d || d.kind === "group")
+        return !1;
+      if (t === "delete-selected-rows") {
+        if (v.length === 0)
+          return !1;
+        const p = we(), x = Xe(v);
+        return x && be(p, v.length > 1 ? `Delete ${v.length} rows` : "Delete row"), x;
+      }
+      if (t === "insert-row-above") {
+        if (!Se())
+          return !1;
+        const p = we(), x = e.runtime.api.rows.insertDataBefore(
+          n,
+          [Ft(d.data, Le(o))]
+        );
+        return x && be(p, "Insert row above"), x;
+      }
+      if (t === "insert-row-below") {
+        if (!Se())
+          return !1;
+        const p = we(), x = e.runtime.api.rows.insertDataAfter(
+          n,
+          [Ft(d.data, Le(o))]
+        );
+        return x && be(p, "Insert row below"), x;
+      }
+      return !1;
+    }
+    Et = async (t, n) => {
+      const o = String(n);
+      if (t === "open-row-menu")
+        return wl(o);
+      if (t === "insert-row-above" || t === "insert-row-below" || t === "delete-selected-rows")
+        return xn(t, n);
+      const s = St(o);
+      if (s != null) {
+        if (t === "paste-row") {
+          if (!Se())
+            return !1;
+          const v = await It();
+          if (!v || v.length === 0)
+            return !1;
+          const f = we(), p = ae.value?.operation === "cut" ? ae.value.sourceRowIds : [];
+          if (!el(s + 1))
+            return !1;
+          const P = Math.max(0, s + 1), k = Le(
+            p[0] ?? o
+          ) ?? Le(o), K = p.length > 0 ? At(p, P) : e.runtime.api.rows.insertDataAt(
+            P,
+            v.map((Z) => gn(Z, k))
+          );
+          return K && ae.value?.operation === "cut" && (ae.value = null), K && be(
+            f,
+            p.length > 0 ? p.length > 1 ? `Move ${p.length} rows` : "Move row" : v.length > 1 ? `Paste ${v.length} rows` : "Paste row"
+          ), K;
+        }
+        return !1;
+      }
+      const d = it(o);
+      if (!d || d.kind === "group")
+        return !1;
+      if (t === "copy-row") {
+        const v = $e(Je(o)), f = hn(v);
+        return fn(
+          f.length > 0 ? f : [d.data],
+          "copy",
+          v.length > 0 ? v : [o]
+        );
+      }
+      if (t === "cut-row") {
+        const v = $e(Je(o)), f = hn(v);
+        return fn(
+          f.length > 0 ? f : [d.data],
+          "cut",
+          v.length > 0 ? v : [o]
+        );
+      }
+      if (t === "paste-row") {
+        if (!Se())
+          return !1;
+        const v = await It();
+        if (!v || v.length === 0)
+          return !1;
+        const f = we(), p = ae.value?.operation === "cut" ? ae.value.sourceRowIds : [], x = Le(
+          p[0] ?? o
+        ) ?? Le(o), P = p.length > 0 ? tl(p, o) : e.runtime.api.rows.insertDataAfter(
+          n,
+          v.map((k) => gn(k, x))
+        );
+        return P && ae.value?.operation === "cut" && (ae.value = null), P && be(
+          f,
+          p.length > 0 ? p.length > 1 ? `Move ${p.length} rows` : "Move row" : v.length > 1 ? `Paste ${v.length} rows` : "Paste row"
+        ), P;
+      }
+      return !1;
+    };
+    const gl = Ur({
+      resolveContextMenuState: () => ({
+        zone: ce.value.zone,
+        columnKey: ce.value.columnKey,
+        rowId: ce.value.rowId
+      }),
+      runHeaderContextAction: () => !1,
+      runRowIndexContextAction: Et,
+      copySelection: ll,
+      pasteSelection: rl,
+      cutSelection: ol,
+      clearCurrentSelection: al,
+      closeContextMenu: Ee
+    }), Ne = q([]), zt = (t) => Ne.value.includes(t), vl = (t) => {
+      Ne.value = Ne.value.filter((n) => n !== t && !n.startsWith(`${t}/`));
+    }, hl = (t, n = []) => {
+      if (zt(t)) {
+        vl(t);
+        return;
+      }
+      Ne.value = Array.from(/* @__PURE__ */ new Set([...n, t]));
+    }, bl = (t, n, o, s, d) => {
+      const f = d[n === "paste-values" ? "pasteValues" : n];
+      if (f?.hidden)
+        return null;
+      const p = o.has(t) || f?.disabled === !0;
+      return {
+        kind: "action",
+        id: n,
+        label: f?.label ?? er[n],
+        disabled: p,
+        title: f?.disabledReason ?? s[t],
+        actionId: n
+      };
+    }, H = (t, n, o) => {
+      if (t.hidden === !0)
+        return null;
+      const s = n.length > 0 ? `${n}/${t.key}` : t.key, d = `custom:${s}`, v = t.disabledReason?.trim() || void 0;
+      if (t.kind === "submenu") {
+        const f = t.items.flatMap((p) => {
+          const x = H(p, s, o);
+          return x ? [x] : [];
+        });
+        return f.length === 0 ? null : {
+          kind: "submenu",
+          id: d,
+          label: t.label,
+          disabled: t.disabled === !0,
+          title: v,
+          entries: f
+        };
+      }
+      return {
+        kind: "action",
+        id: d,
+        label: t.label,
+        disabled: t.disabled === !0,
+        title: v,
+        onSelect: async () => {
+          t.disabled !== !0 && await t.onSelect?.({
+            zone: o.zone,
+            columnKey: o.columnKey,
+            rowId: o.rowId,
+            closeMenu: Ee
+          });
+        }
+      };
+    }, yl = (t, n, o) => {
+      const s = /* @__PURE__ */ new Map(), d = (f, p) => {
+        if (!p)
+          return;
+        const x = s.get(f) ?? [];
+        x.push([p]), s.set(f, x);
+      };
+      for (const f of n)
+        d(f.placement ?? "end", H(f, "", o));
+      const v = [
+        ...s.get("start") ?? []
+      ];
+      for (const f of t)
+        v.push(...s.get(`before:${f.itemKey}`) ?? []), v.push([...f.entries]), v.push(...s.get(`after:${f.itemKey}`) ?? []);
+      return v.push(...s.get("end") ?? []), v.filter((f) => f.length > 0);
+    }, Mn = w(() => {
+      if (!ce.value.visible)
+        return [];
+      const t = ce.value.zone;
+      if (t === "cell" || t === "range") {
+        const n = ce.value.columnKey ?? "";
+        if (!e.cellMenu.enabled || !n)
+          return [];
+        const o = On(e.cellMenu, n), s = new Set(Oo(e.cellMenu, n)), d = ko(e.cellMenu, n), v = _o(e.cellMenu, n), f = Eo(e.cellMenu, n), p = Po(e.cellMenu, n), x = [];
+        for (const P of o) {
+          const K = (ba[P] ?? []).flatMap((Z) => {
+            const me = bl(P, Z, s, d, f);
+            return me ? [me] : [];
+          });
+          if (K.length !== 0) {
+            if (P === "pasteSpecial") {
+              const Z = s.has(P) || K.every((me) => me.disabled);
+              x.push({
+                itemKey: P,
+                entries: [{
+                  kind: "submenu",
+                  id: "paste-special-submenu",
+                  label: v.pasteSpecial ?? "Paste special",
+                  disabled: Z,
+                  title: d[P] ?? (K.length === 1 ? K[0]?.title : void 0),
+                  entries: K
+                }]
+              });
+              continue;
+            }
+            x.push({
+              itemKey: P,
+              entries: K
+            });
+          }
+        }
+        return yl(x, p, {
+          zone: t,
+          columnKey: n,
+          rowId: ce.value.rowId
+        });
+      }
+      if (t === "row-index") {
+        if (!e.rowIndexMenu.enabled)
+          return [];
+        const n = St(ce.value.rowId ?? ""), o = To(e.rowIndexMenu), s = new Set(zo(e.rowIndexMenu)), d = Ho(e.rowIndexMenu), v = Vo(e.rowIndexMenu), f = [];
+        for (const p of o) {
+          const P = (ya[p] ?? []).flatMap((k) => {
+            const Z = v[k === "insert-row-above" ? "insertAbove" : k === "insert-row-below" ? "insertBelow" : k === "copy-row" ? "copy" : k === "paste-row" ? "paste" : k === "delete-selected-rows" ? "deleteSelected" : "cut"];
+            if (Z?.hidden)
+              return [];
+            let Re = s.has(p) || Z?.disabled === !0, Q = Z?.disabledReason ?? d[p];
+            return n != null && k !== "delete-selected-rows" && k !== "insert-row-above" && k !== "insert-row-below" && k !== "paste-row" && (Re = !0, Q = Q ?? "Placeholder rows must be materialized before this action is available"), (k === "insert-row-above" || k === "insert-row-below") && !Se() && !Rn() && (Re = !0, Q = Q ?? "Row insertion is not supported by the current row model"), k === "paste-row" && !Se() && (Re = !0, Q = Q ?? "Row insertion is not supported by the current row model"), k === "cut-row" && !Oe() && (Re = !0, Q = Q ?? "Row deletion is not supported by the current row model"), k === "delete-selected-rows" && !Oe() && !Rn() && (Re = !0, Q = Q ?? "Row deletion is not supported by the current row model"), k === "delete-selected-rows" && $e(
+              Je(ce.value.rowId ?? "")
+            ).length === 0 && (Re = !0, Q = Q ?? "No deletable rows are selected"), [{
+              kind: "action",
+              id: k,
+              label: nl(k, Z?.label),
+              disabled: Re,
+              title: Q,
+              actionId: k
+            }];
+          });
+          P.length > 0 && f.push(P);
+        }
+        return f;
+      }
+      return [];
+    }), c = (t) => {
+      ml.dispatchViewportContextMenu(t);
+    }, y = () => {
+      pe.value?.querySelector(".grid-body-viewport")?.focus({ preventScroll: !0 });
+    }, S = () => {
+      et(() => {
+        if (typeof window < "u") {
+          window.requestAnimationFrame(() => {
+            y();
+          });
+          return;
+        }
+        y();
+      });
+    }, D = async (t) => {
+      await gl.runContextMenuAction(t) && (y(), Ee(), S());
+    }, ee = async (t) => {
+      if (!t.disabled && t.kind !== "submenu") {
+        if (t.actionId) {
+          await D(t.actionId);
+          return;
+        }
+        await t.onSelect?.();
+      }
+    }, U = (t, n = [], o = 0) => t.flatMap((s) => {
+      if (s.kind === "submenu") {
+        const d = zt(s.id), v = d ? B("div", {
+          class: "datagrid-context-menu__submenu-panel",
+          role: "menu",
+          "data-datagrid-menu-parent-action": s.id
+        }, U(s.entries, [...n, s.id], o + 1)) : null;
+        return [B("div", {
+          class: [
+            "datagrid-context-menu__submenu",
+            d ? "datagrid-context-menu__submenu--open" : null
+          ]
+        }, [
+          B("button", {
+            type: "button",
+            class: [
+              "datagrid-context-menu__item",
+              "datagrid-context-menu__item--submenu"
+            ],
+            "data-datagrid-menu-action": s.id,
+            "data-datagrid-menu-depth": String(o),
+            "data-datagrid-menu-open": d ? "true" : void 0,
+            "aria-haspopup": "menu",
+            "aria-expanded": d ? "true" : "false",
+            disabled: s.disabled,
+            title: s.title,
+            onClick: () => {
+              hl(s.id, n);
+            }
+          }, [
+            B("span", s.label),
+            B("span", {
+              class: "datagrid-context-menu__submenu-arrow",
+              "aria-hidden": "true"
+            }, ">")
+          ]),
+          ...v ? [v] : []
+        ])];
+      }
+      return [B("button", {
+        type: "button",
+        class: "datagrid-context-menu__item",
+        "data-datagrid-menu-action": s.id,
+        "data-datagrid-menu-depth": String(o),
+        disabled: s.disabled,
+        title: s.title,
+        onClick: () => {
+          ee(s);
+        }
+      }, s.label)];
+    }), V = () => !ce.value.visible || Mn.value.length === 0 ? null : B("div", {
+      ref: In,
+      class: "datagrid-context-menu",
+      style: dl.value,
+      role: "menu",
+      tabindex: -1,
+      onKeydown: (t) => {
+        cl(t, {
+          onEscape: () => {
+            y();
+          }
+        });
+      }
+    }, Mn.value.flatMap((t, n) => {
+      const o = [];
+      return n > 0 && o.push(B("div", {
+        class: "datagrid-context-menu__separator",
+        "aria-hidden": "true"
+      })), o.push(...U(t)), o;
+    }));
+    te(
+      () => ce.value.visible,
+      (t, n, o) => {
+        if (t || (Ne.value = []), !t || typeof window > "u")
+          return;
+        const s = (v) => {
+          const f = v.target;
+          f && In.value?.contains(f) || Ee();
+        }, d = () => {
+          Ee();
+        };
+        window.addEventListener("mousedown", s, !0), window.addEventListener("blur", d), o(() => {
+          window.removeEventListener("mousedown", s, !0), window.removeEventListener("blur", d);
+        });
+      }
+    );
+    const $ = w(() => ({
+      ...Ze.value,
+      customOverlays: e.customOverlays,
+      columns: {
+        ...Ze.value.columns,
+        columnMenuEnabled: e.columnMenu.enabled,
+        columnMenuTrigger: e.columnMenu.trigger,
+        columnMenuMaxFilterValues: e.columnMenu.maxFilterValues,
+        resolveColumnMenuItems: Kt,
+        resolveColumnMenuDisabledItems: Nt,
+        resolveColumnMenuDisabledReasons: Wt,
+        resolveColumnMenuLabels: vt,
+        resolveColumnMenuActionOptions: Ut,
+        resolveColumnMenuCustomItems: qt,
+        isColumnFilterActive: Lt,
+        isColumnGrouped: Jt,
+        resolveColumnGroupOrder: Yt,
+        resolveColumnMenuSortDirection: rn,
+        resolveColumnMenuSelectedTokens: W,
+        applyColumnMenuSort: at,
+        applyColumnMenuPin: Ae,
+        applyColumnMenuGroupBy: Be,
+        applyColumnMenuFilter: De,
+        clearColumnMenuFilter: bt
+      },
+      rows: {
+        ...Ze.value.rows,
+        sourceRows: e.rows,
+        rowHover: e.rowHover,
+        stripedRows: e.stripedRows
+      }
+    })), ue = w(() => {
+      const t = [];
+      return e.history.enabled && e.history.controls === "toolbar" && (t.push({
+        key: "history-undo",
+        component: Ul,
+        props: {
+          action: "undo",
+          label: "Undo",
+          disabled: !ke.canUndo(),
+          onTrigger: () => ke.runHistoryAction("undo")
+        }
+      }), t.push({
+        key: "history-redo",
+        component: Ul,
+        props: {
+          action: "redo",
+          label: "Redo",
+          disabled: !ke.canRedo(),
+          onTrigger: () => ke.runHistoryAction("redo")
+        }
+      })), e.columnLayout.enabled && t.push({
+        key: "column-layout",
+        component: bo,
+        props: {
+          isOpen: ft.value,
+          items: wt.value,
+          buttonLabel: e.columnLayout.buttonLabel,
+          labels: e.columnLayout.labels,
+          active: !1,
+          onOpen: We,
+          onToggleVisibility: gt,
+          onMoveUp: _,
+          onMoveDown: le,
+          onMoveToPosition: (n) => {
+            Pn(n.key, n.targetKey, n.placement);
+          },
+          onApply: z,
+          onCancel: T
+        }
+      }), e.advancedFilter.enabled && t.push({
+        key: "advanced-filter",
+        component: ta,
+        props: {
+          isOpen: Bt.value,
+          clauses: N.value,
+          columns: A.value,
+          appliedFilterSummaryItems: rt.value,
+          hasAnyFilters: ot.value,
+          buttonLabel: e.advancedFilter.buttonLabel,
+          labels: e.advancedFilter.labels,
+          active: ot.value,
+          showActiveIcon: ot.value,
+          onOpen: qe,
+          onAdd: Hn,
+          onRemove: Vn,
+          onUpdateClause: Bn,
+          onApply: Qt,
+          onCancel: jn,
+          onResetAll: $n
+        }
+      }), e.findReplace.enabled && t.push({
+        key: "find-replace",
+        component: la,
+        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: na,
+        props: {
+          isOpen: Fe.value,
+          basis: Ue.value,
+          items: Gt.value,
+          buttonLabel: e.aggregations.buttonLabel,
+          active: re.value && (Fe.value || !!lt.value?.columns.length),
+          disabled: !re.value,
+          disabledReason: re.value ? "" : "Aggregations require an active group-by model.",
+          onOpen: Wn,
+          onUpdateBasis: ln,
+          onToggleColumn: Un,
+          onUpdateOp: qn,
+          onClear: ht,
+          onApply: Yn,
+          onCancel: nn
+        }
+      }), [...t, ...e.toolbarModules].map(ra);
+    });
+    te(
+      ue,
+      (t) => {
+        e.reportToolbarModules?.(t);
+      },
+      { immediate: !0, flush: "post" }
+    );
+    const X = w(() => e.viewMode === "gantt" && e.chrome.toolbarPlacement === "integrated" ? "stacked" : e.chrome.toolbarPlacement), ye = w(() => ue.value.length > 0 && X.value !== "hidden"), ge = w(() => ye.value && X.value === "stacked"), Fn = w(() => ye.value && X.value === "integrated");
+    return () => B("div", {
+      class: [
+        "datagrid-app-layout",
+        `datagrid-app-layout--toolbar-${X.value}`,
+        `datagrid-app-layout--density-${e.chrome.density}`,
+        e.layoutMode === "auto-height" ? "datagrid-app-layout--auto-height" : "datagrid-app-layout--fill"
+      ],
+      style: l.value
+    }, [
+      ge.value ? B(Wl, {
+        modules: ue.value,
+        variant: "standalone"
+      }) : null,
+      B("div", {
+        class: [
+          "datagrid-app-workspace",
+          e.layoutMode === "auto-height" ? "datagrid-app-workspace--auto-height" : "datagrid-app-workspace--fill"
+        ]
+      }, [
+        Fn.value ? B("div", {
+          class: [
+            "datagrid-app-stage-surface",
+            e.layoutMode === "auto-height" ? "datagrid-app-stage-surface--auto-height" : "datagrid-app-stage-surface--fill",
+            "datagrid-app-stage-surface--integrated"
+          ]
+        }, [
+          B(Wl, {
+            modules: ue.value,
+            variant: "integrated"
+          }),
+          B("div", {
+            class: [
+              "datagrid-app-stage",
+              "datagrid-app-stage--integrated",
+              e.layoutMode === "auto-height" ? "datagrid-app-stage--auto-height" : "datagrid-app-stage--fill"
+            ],
+            ref: pe
+          }, [
+            e.viewMode === "gantt" ? B(Kl, {
+              stageContext: _e,
+              runtime: e.runtime,
+              gantt: e.gantt,
+              baseRowHeight: ne.value,
+              rowVersion: r.value
+            }) : B(Nl, {
+              ...$.value,
+              stageContext: _e,
+              onViewportContextMenu: c
+            }),
+            V()
+          ])
+        ]) : B("div", {
+          class: [
+            "datagrid-app-stage",
+            e.layoutMode === "auto-height" ? "datagrid-app-stage--auto-height" : "datagrid-app-stage--fill"
+          ],
+          ref: pe
+        }, [
+          e.viewMode === "gantt" ? B(Kl, {
+            stageContext: _e,
+            runtime: e.runtime,
+            gantt: e.gantt,
+            baseRowHeight: ne.value,
+            rowVersion: r.value
+          }) : B(Nl, {
+            ...$.value,
+            stageContext: _e,
+            onViewportContextMenu: c
+          }),
+          V()
+        ]),
+        e.inspectorPanel ? B("aside", {
+          class: "datagrid-app-inspector-shell"
+        }, [
+          B(e.inspectorPanel.component, {
+            ...e.inspectorPanel.props ?? {}
+          })
+        ]) : null
+      ])
+    ]);
+  }
+});
+function Ua() {
+  return (e) => e;
+}
+const xl = /* @__PURE__ */ new WeakMap(), tr = /* @__PURE__ */ new WeakMap();
+function Ca(e) {
+  if (!e)
+    return;
+  const l = xl.get(e);
+  if (l)
+    return l;
+  const a = e.initialTreeData?.expandedByDefault ?? !1;
+  if (e.initialTreeData?.expandedByDefault === a)
+    return xl.set(e, e), e;
+  const r = {
+    ...e
+  };
+  return e.initialTreeData && (r.initialTreeData = {
+    ...e.initialTreeData,
+    expandedByDefault: a
+  }), xl.set(e, r), r;
+}
+function pa(e) {
+  return !e || e.length === 0 ? [] : e.map((l) => ({ ...l }));
+}
+function Sa(e) {
+  return !e || e.length === 0 ? [] : e.map((l) => ({ ...l }));
+}
+function Ia(e) {
+  return !e || e.length === 0 ? [] : e.map(({ formula: l, ...a }) => ({ ...a }));
+}
+function xa(e) {
+  return !e || e.length === 0 ? [] : e.flatMap((l) => {
+    const a = typeof l.formula == "string" ? l.formula.trim() : "";
+    return a ? [{
+      name: l.key,
+      formula: a
+    }] : [];
+  });
+}
+function Ma(e, l) {
+  const a = /* @__PURE__ */ new Map();
+  for (const r of e)
+    a.set(r.name, { ...r });
+  for (const r of pa(l))
+    a.set(r.name, r);
+  return Array.from(a.values());
+}
+function qa(e) {
+  return Ia(e);
+}
+function Ya(e) {
+  const l = Ca(e.clientRowModelOptions), a = e.enterpriseClientRowModelOptions, r = xa(e.columns), u = e.formulas !== void 0, i = e.computedFields !== void 0, g = e.formulaFunctions !== void 0, h = r.length > 0, R = u || h ? Ma(r, e.formulas) : void 0, E = i ? Sa(e.computedFields) : void 0, O = g ? e.formulaFunctions ?? {} : void 0, G = !!(h || u || i || g);
+  if (!l && !G)
+    return a ? {
+      ...a
+    } : void 0;
+  if (!G) {
+    if (l && !a)
+      return l;
+    if (!l && a)
+      return a;
+    if (l && a) {
+      let I = tr.get(l);
+      I || (I = /* @__PURE__ */ new WeakMap(), tr.set(l, I));
+      const b = I.get(a);
+      if (b)
+        return b;
+      const F = {
+        ...l,
+        ...a
+      };
+      return I.set(
+        a,
+        F
+      ), F;
+    }
+  }
+  return {
+    ...l ?? {},
+    ...i ? { initialComputedFields: E } : {},
+    ...u || h ? { initialFormulaFields: R } : {},
+    ...g ? { initialFormulaFunctionRegistry: O } : {},
+    ...a?.computeMode ? { computeMode: a.computeMode } : {},
+    ...a?.workerPatchDispatchThreshold !== void 0 ? { workerPatchDispatchThreshold: a.workerPatchDispatchThreshold } : {},
+    ...a?.formulaColumnCacheMaxColumns !== void 0 ? { formulaColumnCacheMaxColumns: a.formulaColumnCacheMaxColumns } : {}
+  };
+}
+const Fa = "comfortable", Aa = {
+  comfortable: {
+    toolbarGap: 10,
+    workspaceGap: 12
+  },
+  compact: {
+    toolbarGap: 6,
+    workspaceGap: 8
+  }
+};
+function Da(e) {
+  return e === "compact" ? "compact" : Fa;
+}
+function Oa(e) {
+  return e === "integrated" || e === "hidden" || e === "stacked" ? e : "stacked";
+}
+function nr(e, l) {
+  return Number.isFinite(e) ? Math.max(0, e) : l;
+}
+function Ja(e) {
+  const l = typeof e == "object" && e !== null ? e : null, a = Da(typeof e == "string" ? e : l?.density), r = Aa[a];
+  return {
+    density: a,
+    toolbarPlacement: Oa(l?.toolbarPlacement),
+    toolbarGap: nr(l?.toolbarGap, r.toolbarGap),
+    workspaceGap: nr(l?.workspaceGap, r.workspaceGap)
+  };
+}
+function Xa(e) {
+  return typeof e == "boolean" ? {
+    enabled: e
+  } : e ? {
+    enabled: e.enabled ?? !0
+  } : {
+    enabled: !1
+  };
+}
+function Za(e) {
+  return typeof e == "boolean" ? {
+    enabled: e
+  } : e ? {
+    enabled: e.enabled ?? !0
+  } : {
+    enabled: !1
+  };
+}
+function lr() {
+  const e = globalThis.performance;
+  return e && typeof e.now == "function" ? e.now() : Date.now();
+}
+const _a = (e, l) => {
+  const a = lr();
+  return {
+    result: l(),
+    duration: Math.max(0, lr() - a)
+  };
+};
+function rr(e) {
+  return {
+    projectionStageTimer: _a,
+    ...e ?? {}
+  };
+}
+function Qa(e) {
+  const l = q(0), a = Rl(), r = Ml(
+    e.rowModel.value ? null : Rl({
+      rows: e.rows.value,
+      ...rr(e.clientRowModelOptions.value)
+    })
+  ), u = (R) => {
+    !R || R === e.rowModel.value || "dispose" in R && typeof R.dispose == "function" && R.dispose();
+  }, i = (R) => {
+    !R || R === e.rowModel.value || et(() => {
+      u(R);
+    });
+  }, g = () => {
+    if (e.rowModel.value)
+      return;
+    const R = r.value;
+    r.value = Rl({
+      rows: e.rows.value,
+      ...rr(e.clientRowModelOptions.value)
+    }), l.value += 1, e.onOwnedRowModelRecreated?.(), i(R);
+  }, h = w(() => e.rowModel.value ?? r.value ?? a);
+  return te(
+    e.rows,
+    (R) => {
+      r.value && r.value.setRows(R);
+    },
+    { deep: !1 }
+  ), te(
+    e.clientRowModelOptions,
+    () => {
+      g();
+    },
+    { deep: !0 }
+  ), te(
+    e.rowModel,
+    (R) => {
+      if (R) {
+        const E = r.value;
+        r.value = null, l.value += 1, i(E);
+        return;
+      }
+      r.value || g();
+    }
+  ), Sr(() => {
+    u(r.value), u(a);
+  }), {
+    dataGridInstanceKey: l,
+    resolvedRowModel: h,
+    disposeOwnedRowModel: u
+  };
+}
+export {
+  Wa as D,
+  Wl as a,
+  Xa as b,
+  Ya as c,
+  Za as d,
+  Bo as e,
+  Zo as f,
+  $a as g,
+  Ka as h,
+  Na as i,
+  La as j,
+  qa as k,
+  Ua as l,
+  Ja as r,
+  Qa as u
+};