@affino/datagrid-vue-app 0.1.45 → 0.1.46

package/dist/chunks/useDataGridAppRowModel-DKyzpK78.js

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