@affino/datagrid-vue-app 0.1.39 → 0.1.41

package/dist/chunks/useDataGridAppRowModel-C-OPUq4R.js

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