npm - @lensui/lens-table - Versions diffs - 0.1.0 - Mend

@lensui/lens-table 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,3662 @@
+// src/Table.tsx
+import { Fragment as Fragment2, useCallback as useCallback2, useEffect as useEffect2, useLayoutEffect as useLayoutEffect2, useMemo, useRef as useRef2, useState as useState4 } from "react";
+import { flushSync } from "react-dom";
+// src/components/EmptyState.tsx
+import { useId } from "react";
+// src/core/i18n.ts
+var ZH_CN_GRID_LABELS = {
+  choose: "\u8BF7\u9009\u62E9",
+  selectDate: "\u9009\u62E9\u65E5\u671F",
+  collapseTimePicker: "\u6536\u8D77\u65F6\u95F4\u9009\u62E9\u5668",
+  expandTimePicker: "\u5C55\u5F00\u65F6\u95F4\u9009\u62E9\u5668",
+  startTime: "\u5F00\u59CB\u65F6\u95F4",
+  endTime: "\u7ED3\u675F\u65F6\u95F4",
+  start: "\u5F00\u59CB",
+  end: "\u7ED3\u675F",
+  hour: "\u65F6",
+  minute: "\u5206",
+  second: "\u79D2",
+  confirm: "\u786E\u5B9A",
+  reset: "\u91CD\u7F6E",
+  search: "\u641C\u7D22",
+  filter: "\u7B5B\u9009",
+  filterWithValue: (value) => `\u7B5B\u9009\uFF1A${value}`,
+  sortAsc: "\u5F53\u524D\uFF1A\u5347\u5E8F",
+  sortDesc: "\u5F53\u524D\uFF1A\u964D\u5E8F",
+  sortBoth: "\u5347\u5E8F / \u964D\u5E8F",
+  dragColumn: "\u62D6\u52A8\u5217\u6392\u5E8F",
+  previousYear: "\u4E0A\u4E00\u5E74",
+  nextYear: "\u4E0B\u4E00\u5E74",
+  previousMonth: "\u4E0A\u4E2A\u6708",
+  nextMonth: "\u4E0B\u4E2A\u6708",
+  previousPage: "\u4E0A\u4E00\u9875",
+  nextPage: "\u4E0B\u4E00\u9875",
+  empty: "\u6682\u65E0\u6570\u636E",
+  annotation: "\u6807\u6CE8",
+  annotationMode: "\u6807\u6CE8\u65B9\u5F0F",
+  annotationBackground: "\u80CC\u666F",
+  annotationCorner: "\u89D2\u6807",
+  annotationColor: (index) => `\u989C\u8272 ${index}`,
+  annotationContent: "\u6807\u6CE8\u5185\u5BB9",
+  annotationPlaceholder: "\u8F93\u5165\u6807\u6CE8\u5185\u5BB9",
+  removeAnnotation: "\u53D6\u6D88\u6807\u6CE8",
+  selectRow: "\u9009\u4E2D\u884C",
+  deselectRow: "\u53D6\u6D88\u9009\u4E2D\u884C",
+  selectColumn: "\u9009\u4E2D\u5217",
+  deselectColumn: "\u53D6\u6D88\u9009\u4E2D\u5217",
+  copy: "\u590D\u5236",
+  copyContent: "\u590D\u5236\u5185\u5BB9",
+  copySuccess: "\u590D\u5236\u6210\u529F",
+  copyError: "\u590D\u5236\u5931\u8D25",
+  clear: "\u6E05\u7A7A",
+  clearContent: "\u6E05\u7A7A\u5185\u5BB9",
+  undoChange: "\u64A4\u9500\u4FEE\u6539",
+  undoConfirmTitle: "\u786E\u8BA4\u64A4\u9500",
+  undoConfirmDescription: "\u786E\u5B9A\u64A4\u9500\u8BE5\u5355\u5143\u683C\u7684\u4FEE\u6539\u5417\uFF1F",
+  clearConfirmTitle: "\u786E\u8BA4\u6E05\u7A7A",
+  clearConfirmDescription: "\u786E\u5B9A\u6E05\u7A7A\u8BE5\u5355\u5143\u683C\u5185\u5BB9\u5417\uFF1F\u6B64\u64CD\u4F5C\u65E0\u6CD5\u64A4\u9500\u3002",
+  edit: "\u7F16\u8F91",
+  insertAbove: "\u5411\u4E0A\u63D2\u5165",
+  insertBelow: "\u5411\u4E0B\u63D2\u5165",
+  insertAboveCount: "\u5411\u4E0A\u63D2\u5165\u884C\u6570",
+  insertBelowCount: "\u5411\u4E0B\u63D2\u5165\u884C\u6570",
+  rowUnit: "\u884C",
+  moveUp: "\u5411\u4E0A\u79FB\u52A8",
+  moveDown: "\u5411\u4E0B\u79FB\u52A8",
+  deleteRow: "\u5220\u9664\u884C",
+  deleteConfirmTitle: "\u786E\u8BA4\u5220\u9664",
+  deleteConfirmDescription: (count) => `\u786E\u5B9A\u5220\u9664\u9009\u4E2D\u7684 ${count} \u884C\u6570\u636E\u5417\uFF1F\u6B64\u64CD\u4F5C\u65E0\u6CD5\u64A4\u9500\u3002`,
+  cancel: "\u53D6\u6D88",
+  delete: "\u5220\u9664",
+  filterColumn: (title) => `\u7B5B\u9009${title}`,
+  initialLoading: "\u8868\u683C\u52A0\u8F7D\u4E2D",
+  refreshing: "\u6B63\u5728\u5237\u65B0\u6570\u636E"
+};
+var EN_US_GRID_LABELS = {
+  choose: "Choose",
+  selectDate: "Select date",
+  collapseTimePicker: "Collapse time picker",
+  expandTimePicker: "Expand time picker",
+  startTime: "Start time",
+  endTime: "End time",
+  start: "Start",
+  end: "End",
+  hour: "Hour",
+  minute: "Minute",
+  second: "Second",
+  confirm: "Confirm",
+  reset: "Reset",
+  search: "Search",
+  filter: "Filter",
+  filterWithValue: (value) => `Filter: ${value}`,
+  sortAsc: "Current: ascending",
+  sortDesc: "Current: descending",
+  sortBoth: "Ascending / descending",
+  dragColumn: "Drag column to reorder",
+  previousYear: "Previous year",
+  nextYear: "Next year",
+  previousMonth: "Previous month",
+  nextMonth: "Next month",
+  previousPage: "Previous page",
+  nextPage: "Next page",
+  empty: "No data",
+  annotation: "Annotation",
+  annotationMode: "Annotation mode",
+  annotationBackground: "Background",
+  annotationCorner: "Corner",
+  annotationColor: (index) => `Color ${index}`,
+  annotationContent: "Annotation content",
+  annotationPlaceholder: "Enter annotation",
+  removeAnnotation: "Remove annotation",
+  selectRow: "Select row",
+  deselectRow: "Deselect row",
+  selectColumn: "Select column",
+  deselectColumn: "Deselect column",
+  copy: "Copy",
+  copyContent: "Copy content",
+  copySuccess: "Copied",
+  copyError: "Copy failed",
+  clear: "Clear",
+  clearContent: "Clear content",
+  undoChange: "Undo change",
+  undoConfirmTitle: "Confirm undo",
+  undoConfirmDescription: "Undo the change in this cell?",
+  clearConfirmTitle: "Confirm clear",
+  clearConfirmDescription: "Clear this cell content? This action cannot be undone.",
+  edit: "Edit",
+  insertAbove: "Insert above",
+  insertBelow: "Insert below",
+  insertAboveCount: "Rows to insert above",
+  insertBelowCount: "Rows to insert below",
+  rowUnit: "rows",
+  moveUp: "Move up",
+  moveDown: "Move down",
+  deleteRow: "Delete row",
+  deleteConfirmTitle: "Confirm delete",
+  deleteConfirmDescription: (count) => `Delete ${count} selected row(s)? This action cannot be undone.`,
+  cancel: "Cancel",
+  delete: "Delete",
+  filterColumn: (title) => `Filter ${title}`,
+  initialLoading: "Loading grid",
+  refreshing: "Refreshing"
+};
+var GRID_LABELS_BY_LOCALE = {
+  "zh-CN": ZH_CN_GRID_LABELS,
+  "en-US": EN_US_GRID_LABELS
+};
+function resolveGridLocale(config) {
+  if (!config || typeof config === "string") {
+    const language2 = config ?? "zh-CN";
+    return { language: language2, labels: GRID_LABELS_BY_LOCALE[language2] };
+  }
+  const { language = "zh-CN", labels } = config;
+  return { language, labels: { ...GRID_LABELS_BY_LOCALE[language], ...labels } };
+}
+// src/components/EmptyState.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function DefaultEmptyState({ label = ZH_CN_GRID_LABELS.empty }) {
+  const id = useId().replace(/:/g, "");
+  const gradientOne = `${id}-empty-gradient-one`;
+  const gradientTwo = `${id}-empty-gradient-two`;
+  const mask = `${id}-empty-mask`;
+  return /* @__PURE__ */ jsxs("div", { className: "rvg-default-empty", children: [
+    /* @__PURE__ */ jsxs("svg", { viewBox: "0 0 79 86", "aria-hidden": "true", children: [
+      /* @__PURE__ */ jsxs("defs", { children: [
+        /* @__PURE__ */ jsxs("linearGradient", { id: gradientOne, x1: "38.8503086%", y1: "0%", x2: "61.1496914%", y2: "100%", children: [
+          /* @__PURE__ */ jsx("stop", { stopColor: "#fcfcfd", offset: "0%" }),
+          /* @__PURE__ */ jsx("stop", { stopColor: "#eeeff3", offset: "100%" })
+        ] }),
+        /* @__PURE__ */ jsxs("linearGradient", { id: gradientTwo, x1: "0%", y1: "9.5%", x2: "100%", y2: "90.5%", children: [
+          /* @__PURE__ */ jsx("stop", { stopColor: "#fcfcfd", offset: "0%" }),
+          /* @__PURE__ */ jsx("stop", { stopColor: "#e9ebef", offset: "100%" })
+        ] }),
+        /* @__PURE__ */ jsx("mask", { id: mask, children: /* @__PURE__ */ jsx("rect", { width: "17", height: "36", fill: "#fff" }) })
+      ] }),
+      /* @__PURE__ */ jsx("path", { d: "M39.5 86C61.315 86 79 83.91 79 81.333 79 78.756 57.315 78 35.5 78S0 78.756 0 81.333C0 83.91 17.685 86 39.5 86Z", fill: "#f7f8fc" }),
+      /* @__PURE__ */ jsx("path", { d: "M13 45h40L42 58H2z", fill: "#e5e7e9" }),
+      /* @__PURE__ */ jsxs("g", { transform: "translate(34.5 31.5) scale(-1 1) rotate(-25) translate(-27.5 -21.5)", children: [
+        /* @__PURE__ */ jsx("path", { d: "M0 3h18l5 4H5z", fill: "#e5e7e9" }),
+        /* @__PURE__ */ jsx("path", { d: "M0 7h38v36H0z", fill: "#edeef2" }),
+        /* @__PURE__ */ jsx("path", { d: "M38 7h17v36H38z", fill: `url(#${gradientOne})` }),
+        /* @__PURE__ */ jsx("path", { d: "M24 7h17L55 0H38z", fill: "#f8f9fb" })
+      ] }),
+      /* @__PURE__ */ jsx("rect", { x: "13", y: "45", width: "40", height: "36", fill: `url(#${gradientTwo})` }),
+      /* @__PURE__ */ jsxs("g", { transform: "translate(53 45)", mask: `url(#${mask})`, children: [
+        /* @__PURE__ */ jsx("rect", { width: "17", height: "36", fill: "#e0e3e9" }),
+        /* @__PURE__ */ jsx("path", { d: "M7 0h17l-4 18L0 16z", fill: "#d5d7de" })
+      ] }),
+      /* @__PURE__ */ jsx("path", { d: "M62 45h17l-9 13H53z", fill: "#f8f9fb" })
+    ] }),
+    /* @__PURE__ */ jsx("span", { children: label })
+  ] });
+}
+// src/components/editors/ChoiceEditor.tsx
+import { Portal } from "@ark-ui/react/portal";
+import { Select, createListCollection } from "@ark-ui/react/select";
+// src/icons/gridIcons.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function CalendarIcon() {
+  return /* @__PURE__ */ jsxs2("svg", { className: "rvg-calendar-icon", viewBox: "0 0 1024 1024", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx2("path", { d: "M825.94 181.85H741.7v-54.42c0-15.79-12.22-28.6-27.3-28.6s-27.3 12.81-27.3 28.6v54.42H336.9v-54.42c0-15.79-12.22-28.6-27.3-28.6s-27.3 12.81-27.3 28.6v54.42h-84.24c-45.16 0-81.9 38.49-81.9 85.8v571.73c0 47.31 36.74 85.79 81.9 85.79h627.88c45.16 0 81.9-38.48 81.9-85.79V267.65c-.01-47.31-36.74-85.8-81.9-85.8zm-627.88 57.2h84.24v50.65c0 15.79 12.22 28.6 27.3 28.6s27.3-12.8 27.3-28.6v-50.65h350.2v50.65c0 15.79 12.22 28.6 27.3 28.6s27.3-12.8 27.3-28.6v-50.65h84.24c15.06 0 27.3 12.82 27.3 28.6v138.93H170.76V267.65c0-15.78 12.25-28.6 27.3-28.6zm627.88 628.92H198.06c-15.06 0-27.3-12.83-27.3-28.6v-375.6h682.47v375.6c.01 15.77-12.24 28.6-27.29 28.6z" }),
+    /* @__PURE__ */ jsx2("path", { d: "M641.08 629.99H382.92c-15.08 0-27.3 12.8-27.3 28.6s12.22 28.6 27.3 28.6h258.15c15.08 0 27.3-12.8 27.3-28.6s-12.22-28.6-27.29-28.6z" })
+  ] });
+}
+function YearStepIcon({ direction }) {
+  const paths = direction === "previous" ? ["M10.5 3.5 6 8l4.5 4.5", "M15 3.5 10.5 8l4.5 4.5"] : ["M5 3.5 9.5 8 5 12.5", "M9.5 3.5 14 8l-4.5 4.5"];
+  return /* @__PURE__ */ jsx2("svg", { className: "rvg-calendar-step-icon", viewBox: "0 0 20 16", "aria-hidden": "true", children: paths.map((path) => /* @__PURE__ */ jsx2("path", { d: path }, path)) });
+}
+function MonthStepIcon({ direction }) {
+  const path = direction === "previous" ? "M12.25 3.5 7.75 8l4.5 4.5" : "M7.75 3.5 12.25 8l-4.5 4.5";
+  return /* @__PURE__ */ jsx2("svg", { className: "rvg-calendar-step-icon", viewBox: "0 0 20 16", "aria-hidden": "true", children: /* @__PURE__ */ jsx2("path", { d: path }) });
+}
+function TimeIcon() {
+  return /* @__PURE__ */ jsxs2("svg", { className: "rvg-time-icon", viewBox: "0 0 16 16", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx2("circle", { cx: "8", cy: "8", r: "5.5" }),
+    /* @__PURE__ */ jsx2("path", { d: "M8 4.7v3.6l2.4 1.4" })
+  ] });
+}
+function ClearValueIcon() {
+  return /* @__PURE__ */ jsx2("svg", { className: "rvg-clear-icon", viewBox: "0 0 16 16", "aria-hidden": "true", children: /* @__PURE__ */ jsx2("path", { d: "m4.25 4.25 7.5 7.5M11.75 4.25l-7.5 7.5" }) });
+}
+function ChoiceChevronIcon() {
+  return /* @__PURE__ */ jsx2("svg", { className: "rvg-choice-chevron", viewBox: "0 0 16 16", "aria-hidden": "true", children: /* @__PURE__ */ jsx2("path", { d: "m4 6 4 4 4-4" }) });
+}
+function ChoiceCheckIcon() {
+  return /* @__PURE__ */ jsx2("svg", { className: "rvg-choice-check", viewBox: "0 0 16 16", "aria-hidden": "true", children: /* @__PURE__ */ jsx2("path", { d: "m3.5 8 2.6 2.6L12.5 4" }) });
+}
+function HeaderDragIcon({ className, style }) {
+  return /* @__PURE__ */ jsxs2("svg", { className, style, viewBox: "0 0 14 14", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx2("circle", { cx: "7", cy: "2.5", r: "1.25" }),
+    /* @__PURE__ */ jsx2("circle", { cx: "7", cy: "7", r: "1.25" }),
+    /* @__PURE__ */ jsx2("circle", { cx: "7", cy: "11.5", r: "1.25" })
+  ] });
+}
+function HeaderSortIcon({ className, style, direction }) {
+  return /* @__PURE__ */ jsxs2("svg", { className, style, viewBox: "0 0 14 14", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx2("path", { className: direction === "asc" ? "is-active" : "", d: "M3 5.5 7 1.5l4 4Z" }),
+    /* @__PURE__ */ jsx2("path", { className: direction === "desc" ? "is-active" : "", d: "M3 8.5 7 12.5l4-4Z" })
+  ] });
+}
+function HeaderSearchIcon({ className, style }) {
+  return /* @__PURE__ */ jsxs2("svg", { className, style, viewBox: "0 0 14 14", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx2("circle", { cx: "5.5", cy: "5.5", r: "4.25" }),
+    /* @__PURE__ */ jsx2("path", { d: "m8.75 8.75 2.25 2.25" })
+  ] });
+}
+function SelectionIcon({ checked, indeterminate = false, radio = false }) {
+  if (radio) {
+    return /* @__PURE__ */ jsxs2("svg", { className: `rvg-selection-svg rvg-radio-svg${checked ? " is-active" : ""}`, viewBox: "0 0 16 16", focusable: "false", "aria-hidden": "true", children: [
+      /* @__PURE__ */ jsx2("circle", { className: "rvg-selection-outline", cx: "8", cy: "8", r: "6.25" }),
+      checked && /* @__PURE__ */ jsx2("circle", { className: "rvg-selection-dot", cx: "8", cy: "8", r: "3.25" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2("svg", { className: `rvg-selection-svg rvg-checkbox-svg${checked || indeterminate ? " is-active" : ""}`, viewBox: "0 0 16 16", focusable: "false", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx2("rect", { className: "rvg-selection-outline", x: "1.5", y: "1.5", width: "13", height: "13", rx: "3" }),
+    indeterminate ? /* @__PURE__ */ jsx2("path", { className: "rvg-selection-mark", d: "M4.25 8h7.5" }) : checked && /* @__PURE__ */ jsx2("path", { className: "rvg-selection-mark", d: "m4.1 8 2.35 2.35 5.45-5.2" })
+  ] });
+}
+function SubmenuArrowIcon() {
+  return /* @__PURE__ */ jsx2("svg", { viewBox: "0 0 16 16", "aria-hidden": "true", children: /* @__PURE__ */ jsx2("path", { d: "m6 3.5 4.5 4.5L6 12.5" }) });
+}
+function ContextMenuIcon({ type }) {
+  if (type === "remove-annotation") {
+    return /* @__PURE__ */ jsxs2("svg", { className: "rvg-context-menu-svg", viewBox: "0 0 16 16", "aria-hidden": "true", children: [
+      /* @__PURE__ */ jsx2("path", { d: "M3.4 3.5h9.2v6.5H7.5L4 13v-3H3.4Z" }),
+      /* @__PURE__ */ jsx2("path", { d: "M2.6 6.8h10.8" })
+    ] });
+  }
+  const paths = {
+    edit: ["M4 11.5 4.5 8.8 10.8 2.5a1.4 1.4 0 0 1 2 2L6.5 10.8 4 11.5Z", "M9.8 3.5l2.7 2.7"],
+    copy: ["M5.5 5.5h6v6h-6Z", "M3.5 9.5h-1v-7h7v1"],
+    undo: ["M5.5 5 3 7.5 5.5 10", "M3.2 7.5H9a3 3 0 1 1 0 6H6.5"],
+    clear: ["M4 4 12 12", "M12 4 4 12"],
+    annotation: ["M3.5 3.5h9v6.5h-5L4 13v-3H3.5Z"],
+    "select-row": ["M3 4.5h10", "M3 8h10", "M3 11.5h10"],
+    "select-column": ["M4.5 3v10", "M8 3v10", "M11.5 3v10"],
+    "insert-above": ["M8 12.5v-7", "M5.5 8 8 5.5 10.5 8", "M3 3.5h10"],
+    "insert-below": ["M8 3.5v7", "M5.5 8 8 10.5 10.5 8", "M3 12.5h10"],
+    "move-up": ["M8 12.5v-9", "M4.5 7 8 3.5 11.5 7"],
+    "move-down": ["M8 3.5v9", "M4.5 9 8 12.5 11.5 9"],
+    delete: ["M3.5 4.5h9", "M6 4.5v-1h4v1", "M5 6.5v6h6v-6"]
+  };
+  return /* @__PURE__ */ jsx2("svg", { className: "rvg-context-menu-svg", viewBox: "0 0 16 16", "aria-hidden": "true", children: paths[type].map((path) => /* @__PURE__ */ jsx2("path", { d: path }, path)) });
+}
+function RowDragHandleIcon() {
+  return /* @__PURE__ */ jsxs2("svg", { viewBox: "0 0 16 16", focusable: "false", children: [
+    /* @__PURE__ */ jsx2("circle", { cx: "5", cy: "4", r: "1" }),
+    /* @__PURE__ */ jsx2("circle", { cx: "11", cy: "4", r: "1" }),
+    /* @__PURE__ */ jsx2("circle", { cx: "5", cy: "8", r: "1" }),
+    /* @__PURE__ */ jsx2("circle", { cx: "11", cy: "8", r: "1" }),
+    /* @__PURE__ */ jsx2("circle", { cx: "5", cy: "12", r: "1" }),
+    /* @__PURE__ */ jsx2("circle", { cx: "11", cy: "12", r: "1" })
+  ] });
+}
+function LoadingSpinnerIcon() {
+  return /* @__PURE__ */ jsx2("svg", { viewBox: "0 0 24 24", "aria-hidden": "true", children: /* @__PURE__ */ jsx2("path", { d: "M20 12a8 8 0 1 1-3.1-6.3" }) });
+}
+// src/components/editors/ChoiceEditor.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ChoiceEditor({ value, options, style, labels, onChange, onCommit, onCancel }) {
+  const collection = createListCollection({
+    items: options,
+    itemToValue: (item) => item.value,
+    itemToString: (item) => item.label
+  });
+  return /* @__PURE__ */ jsxs3(
+    Select.Root,
+    {
+      className: "rvg-choice-editor",
+      style,
+      collection,
+      value: value ? [value] : [],
+      defaultOpen: true,
+      closeOnSelect: true,
+      lazyMount: true,
+      unmountOnExit: true,
+      positioning: { sameWidth: true, placement: "bottom-start" },
+      onSelect: (details) => {
+        onChange(details.value);
+        onCommit(details.value);
+      },
+      onValueChange: (details) => onChange(details.value[0] ?? ""),
+      onKeyDown: (event) => {
+        event.stopPropagation();
+        if (event.key === "Escape") onCancel();
+      },
+      onKeyUp: (event) => {
+        event.stopPropagation();
+        if (event.key === "Enter") onCommit();
+      },
+      children: [
+        /* @__PURE__ */ jsx3(Select.Control, { children: /* @__PURE__ */ jsxs3(Select.Trigger, { autoFocus: true, children: [
+          /* @__PURE__ */ jsx3(Select.ValueText, { placeholder: labels.choose }),
+          /* @__PURE__ */ jsx3(Select.Indicator, { children: /* @__PURE__ */ jsx3(ChoiceChevronIcon, {}) })
+        ] }) }),
+        /* @__PURE__ */ jsx3(Portal, { children: /* @__PURE__ */ jsx3(Select.Positioner, { children: /* @__PURE__ */ jsx3(Select.Content, { className: "rvg-choice-content", children: options.map((option) => /* @__PURE__ */ jsxs3(Select.Item, { className: "rvg-choice-item", item: option, children: [
+          /* @__PURE__ */ jsx3(Select.ItemText, { children: option.label }),
+          /* @__PURE__ */ jsx3(Select.ItemIndicator, { children: /* @__PURE__ */ jsx3(ChoiceCheckIcon, {}) })
+        ] }, option.value)) }) }) }),
+        /* @__PURE__ */ jsx3(Select.HiddenSelect, {})
+      ]
+    }
+  );
+}
+// src/components/editors/DateEditor.tsx
+import { useState as useState2 } from "react";
+import { DatePicker } from "@ark-ui/react/date-picker";
+import { Portal as Portal2 } from "@ark-ui/react/portal";
+import { parseDate as parseDate2 } from "@internationalized/date";
+// src/core/dateTime.ts
+import { parseDate } from "@internationalized/date";
+var TIME_HOURS = Array.from({ length: 24 }, (_, index) => String(index).padStart(2, "0"));
+var TIME_MINUTES = Array.from({ length: 60 }, (_, index) => String(index).padStart(2, "0"));
+var TIME_SECONDS = Array.from({ length: 60 }, (_, index) => String(index).padStart(2, "0"));
+function inferDateFormat(value) {
+  const sample = value.split(" ~ ")[0]?.trim() ?? "";
+  const yearFirst = sample.match(/^\d{4}([^\d])\d{1,2}\1\d{1,2}$/);
+  if (yearFirst) return `YYYY${yearFirst[1]}MM${yearFirst[1]}DD`;
+  const yearLast = sample.match(/^\d{1,2}([^\d])\d{1,2}\1\d{4}$/);
+  if (yearLast) return `MM${yearLast[1]}DD${yearLast[1]}YYYY`;
+  return "YYYY-MM-DD";
+}
+function parseFormattedDate(value, format) {
+  const tokens = ["YYYY", "MM", "DD"];
+  const groups = [];
+  let source = "";
+  for (let index = 0; index < format.length; ) {
+    const token = tokens.find((candidate) => format.startsWith(candidate, index));
+    if (token) {
+      groups.push(token);
+      source += token === "YYYY" ? "(\\d{4})" : "(\\d{1,2})";
+      index += token.length;
+    } else {
+      source += format[index].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      index += 1;
+    }
+  }
+  const match = value.trim().match(new RegExp(`^${source}$`));
+  if (!match) throw new Error("Invalid date");
+  const parts = Object.fromEntries(groups.map((token, index) => [token, match[index + 1]]));
+  return parseDate(`${parts.YYYY}-${String(parts.MM).padStart(2, "0")}-${String(parts.DD).padStart(2, "0")}`);
+}
+function formatDateValue(value, format) {
+  return format.replace(/YYYY/g, String(value.year).padStart(4, "0")).replace(/MM/g, String(value.month).padStart(2, "0")).replace(/DD/g, String(value.day).padStart(2, "0"));
+}
+function timeFormatHasSeconds(format, value) {
+  if (format) return format.includes("ss");
+  return /\d{2}:\d{2}:\d{2}/.test(value);
+}
+// src/components/editors/TimeEditors.tsx
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function CompactTimeEditor({ value, range, showSeconds, style, labels, onChange, onCommit, onCancel }) {
+  const values = range ? value.split(" ~ ") : [value];
+  const [dropdownOpen, setDropdownOpen] = useState(true);
+  const optionRefs = useRef([[], []]);
+  const editorRef = useRef(null);
+  const hasPositionedTimeRef = useRef(false);
+  useEffect(() => {
+    const closeOnOutsidePointer = (event) => {
+      if (!editorRef.current?.contains(event.target)) setDropdownOpen(false);
+    };
+    document.addEventListener("pointerdown", closeOnOutsidePointer, true);
+    return () => document.removeEventListener("pointerdown", closeOnOutsidePointer, true);
+  }, []);
+  useLayoutEffect(() => {
+    if (!dropdownOpen) return;
+    const behavior = hasPositionedTimeRef.current ? "smooth" : "auto";
+    values.forEach((time, index) => {
+      const [hour = "00", minute = "00", second = "00"] = time.split(":");
+      optionRefs.current[index]?.[0]?.scrollTo({ top: Math.max(0, Number(hour) * 28), behavior });
+      optionRefs.current[index]?.[1]?.scrollTo({ top: Math.max(0, Number(minute) * 28), behavior });
+      optionRefs.current[index]?.[2]?.scrollTo({ top: Math.max(0, Number(second) * 28), behavior });
+    });
+    hasPositionedTimeRef.current = true;
+  }, [dropdownOpen, values]);
+  const updatePart = (index, part, nextPart) => {
+    const [hour = "00", minute = "00", second = "00"] = values[index]?.split(":") ?? [];
+    const nextTimeParts = [
+      part === "hour" ? nextPart : hour,
+      part === "minute" ? nextPart : minute
+    ];
+    if (showSeconds) nextTimeParts.push(part === "second" ? nextPart : second);
+    const nextTime = nextTimeParts.join(":");
+    const nextValues = [...values];
+    nextValues[index] = nextTime;
+    const nextValue = range ? `${nextValues[0] ?? ""} ~ ${nextValues[1] ?? ""}` : nextTime;
+    onChange(nextValue);
+  };
+  return /* @__PURE__ */ jsxs4("div", { ref: editorRef, className: "rvg-time-editor", style, onKeyDown: (event) => {
+    event.stopPropagation();
+    if (event.key === "Enter") onCommit();
+    if (event.key === "Escape") onCancel();
+  }, children: [
+    (range ? [value] : values).map((part, index) => /* @__PURE__ */ jsx4("div", { className: "rvg-time-field-group", children: /* @__PURE__ */ jsx4(
+      "input",
+      {
+        value: part,
+        inputMode: "numeric",
+        autoFocus: index === 0,
+        onChange: (event) => onChange(event.target.value)
+      }
+    ) }, index)),
+    /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "button",
+        className: "rvg-time-trigger",
+        "aria-label": dropdownOpen ? labels.collapseTimePicker : labels.expandTimePicker,
+        "aria-expanded": dropdownOpen,
+        onClick: () => setDropdownOpen((open) => !open),
+        children: /* @__PURE__ */ jsx4(TimeIcon, {})
+      }
+    ),
+    /* @__PURE__ */ jsxs4("div", { className: `rvg-time-dropdown${range ? " is-range" : ""}${showSeconds ? " has-seconds" : ""}${dropdownOpen ? " is-open" : ""}`, "aria-hidden": !dropdownOpen, children: [
+      /* @__PURE__ */ jsx4("div", { className: "rvg-time-panels", children: values.map((time, index) => {
+        const [hour = "00", minute = "00", second = "00"] = time.split(":");
+        return /* @__PURE__ */ jsxs4("section", { className: "rvg-time-picker-panel", children: [
+          range && /* @__PURE__ */ jsx4("strong", { children: index === 0 ? labels.startTime : labels.endTime }),
+          /* @__PURE__ */ jsxs4("div", { className: `rvg-time-picker-columns${showSeconds ? " has-seconds" : ""}`, children: [
+            /* @__PURE__ */ jsx4("span", { className: "rvg-time-column-label", children: labels.hour }),
+            /* @__PURE__ */ jsx4("span", { className: "rvg-time-column-label", children: labels.minute }),
+            showSeconds && /* @__PURE__ */ jsx4("span", { className: "rvg-time-column-label", children: labels.second }),
+            /* @__PURE__ */ jsx4("div", { className: "rvg-time-options", ref: (node) => {
+              optionRefs.current[index][0] = node;
+            }, "aria-label": labels.hour, children: TIME_HOURS.map((option) => /* @__PURE__ */ jsx4("button", { type: "button", className: option === hour ? "is-selected" : "", onClick: () => updatePart(index, "hour", option), children: option }, option)) }),
+            /* @__PURE__ */ jsx4("div", { className: "rvg-time-options", ref: (node) => {
+              optionRefs.current[index][1] = node;
+            }, "aria-label": labels.minute, children: TIME_MINUTES.map((option) => /* @__PURE__ */ jsx4("button", { type: "button", className: option === minute ? "is-selected" : "", onClick: () => updatePart(index, "minute", option), children: option }, option)) }),
+            showSeconds && /* @__PURE__ */ jsx4("div", { className: "rvg-time-options", ref: (node) => {
+              optionRefs.current[index][2] = node;
+            }, "aria-label": labels.second, children: TIME_SECONDS.map((option) => /* @__PURE__ */ jsx4("button", { type: "button", className: option === second ? "is-selected" : "", onClick: () => updatePart(index, "second", option), children: option }, option)) })
+          ] })
+        ] }, index);
+      }) }),
+      /* @__PURE__ */ jsx4("div", { className: "rvg-time-footer", children: /* @__PURE__ */ jsx4("button", { type: "button", onClick: () => onCommit(), children: labels.confirm }) })
+    ] })
+  ] });
+}
+function DateTimePanel({ values, labels, showSeconds, onChange }) {
+  const [activeIndex, setActiveIndex] = useState(0);
+  const activeValue = values[activeIndex] ?? "";
+  const [, hour = "00", minute = "00", second = "00"] = activeValue.match(/[T ](\d{2}):(\d{2})(?::(\d{2}))?/) ?? [];
+  const hoursRef = useRef(null);
+  const minutesRef = useRef(null);
+  const secondsRef = useRef(null);
+  const positionedRef = useRef(false);
+  useLayoutEffect(() => {
+    const behavior = positionedRef.current ? "smooth" : "auto";
+    hoursRef.current?.scrollTo({ top: Number(hour) * 28, behavior });
+    minutesRef.current?.scrollTo({ top: Number(minute) * 28, behavior });
+    secondsRef.current?.scrollTo({ top: Number(second) * 28, behavior });
+    positionedRef.current = true;
+  }, [activeIndex, hour, minute, second]);
+  const updatePart = (part, nextPart) => {
+    const nextTimeParts = [
+      part === "hour" ? nextPart : hour,
+      part === "minute" ? nextPart : minute
+    ];
+    if (showSeconds) nextTimeParts.push(part === "second" ? nextPart : second);
+    const nextTime = nextTimeParts.join(":");
+    const nextValues = [...values];
+    const current = nextValues[activeIndex] ?? "";
+    nextValues[activeIndex] = /[T ]\d{2}:\d{2}(?::\d{2})?/.test(current) ? current.replace(/([T ])\d{2}:\d{2}(?::\d{2})?/, `$1${nextTime}`) : `${current || "1970-01-01"}T${nextTime}`;
+    onChange(nextValues);
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: "rvg-date-time-panel", children: [
+    values.length > 1 && /* @__PURE__ */ jsx4("div", { className: "rvg-date-time-tabs", children: values.map((_, index) => /* @__PURE__ */ jsx4("button", { type: "button", className: activeIndex === index ? "is-active" : "", onClick: () => setActiveIndex(index), children: index === 0 ? labels.start : labels.end }, index)) }),
+    /* @__PURE__ */ jsxs4("div", { className: `rvg-date-time-columns${showSeconds ? " has-seconds" : ""}`, children: [
+      /* @__PURE__ */ jsx4("span", { className: "rvg-time-column-label", children: labels.hour }),
+      /* @__PURE__ */ jsx4("span", { className: "rvg-time-column-label", children: labels.minute }),
+      showSeconds && /* @__PURE__ */ jsx4("span", { className: "rvg-time-column-label", children: labels.second }),
+      /* @__PURE__ */ jsx4("div", { className: "rvg-time-options", ref: hoursRef, "aria-label": labels.hour, children: TIME_HOURS.map((option) => /* @__PURE__ */ jsx4("button", { type: "button", className: option === hour ? "is-selected" : "", onClick: () => updatePart("hour", option), children: option }, option)) }),
+      /* @__PURE__ */ jsx4("div", { className: "rvg-time-options", ref: minutesRef, "aria-label": labels.minute, children: TIME_MINUTES.map((option) => /* @__PURE__ */ jsx4("button", { type: "button", className: option === minute ? "is-selected" : "", onClick: () => updatePart("minute", option), children: option }, option)) }),
+      showSeconds && /* @__PURE__ */ jsx4("div", { className: "rvg-time-options", ref: secondsRef, "aria-label": labels.second, children: TIME_SECONDS.map((option) => /* @__PURE__ */ jsx4("button", { type: "button", className: option === second ? "is-selected" : "", onClick: () => updatePart("second", option), children: option }, option)) })
+    ] })
+  ] });
+}
+// src/components/editors/DateEditor.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function DateEditor({ editor, value: draft, style, locale, labels, onChange, onCommit, onCancel }) {
+  const [rangeHoverValue, setRangeHoverValue] = useState2();
+  const editorType = editor.type;
+  const isRange = editorType === "date-range" || editorType === "date-time-range";
+  const isYear = editorType === "year";
+  const isMonth = editorType === "month";
+  const isDateTime = editorType === "date-time" || editorType === "date-time-range";
+  const parts = isRange ? draft.split(" ~ ") : [draft];
+  const editorFormat = editor.format;
+  const dateFormat = editorFormat ?? inferDateFormat(draft);
+  let selectedDates;
+  try {
+    selectedDates = parts.filter(Boolean).map((part) => {
+      if (isYear) return parseDate2(`${part.slice(0, 4)}-01-01`);
+      if (isMonth) return parseDate2(`${part.slice(0, 7)}-01`);
+      if (isDateTime) return parseDate2(part.slice(0, 10).replace(/\//g, "-"));
+      return parseFormattedDate(part, dateFormat);
+    });
+  } catch {
+    selectedDates = [];
+  }
+  const formatSelectedValue = (date, index) => {
+    if (isYear) return String(date.year).padStart(4, "0");
+    if (isMonth) return `${String(date.year).padStart(4, "0")}-${String(date.month).padStart(2, "0")}`;
+    if (isDateTime) {
+      const original = parts[index] ?? "";
+      const [, hour = "00", minute = "00", second = "00"] = original.match(/[T ](\d{2}):(\d{2})(?::(\d{2}))?/) ?? [];
+      if (editorFormat) {
+        return editorFormat.replace(/YYYY/g, String(date.year).padStart(4, "0")).replace(/MM/g, String(date.month).padStart(2, "0")).replace(/DD/g, String(date.day).padStart(2, "0")).replace(/HH/g, hour).replace(/mm/g, minute).replace(/ss/g, second);
+      }
+      const separator = original.includes("/") ? "/" : "-";
+      const datePart = [date.year, String(date.month).padStart(2, "0"), String(date.day).padStart(2, "0")].join(separator);
+      const timePart = original.match(/[T ]\d{2}:\d{2}(?::\d{2})?/)?.[0] ?? " 00:00";
+      return `${datePart}${timePart}`;
+    }
+    return formatDateValue(date, dateFormat);
+  };
+  const initialView = isYear ? "year" : isMonth ? "month" : "day";
+  const rangePreviewClass = (day, month) => {
+    const start = selectedDates[0];
+    const end = selectedDates.length > 1 ? selectedDates[1] : rangeHoverValue;
+    if (!start || !end) return void 0;
+    if (day.year !== month.year || day.month !== month.month) return void 0;
+    const lower = start.compare(end) <= 0 ? start : end;
+    const upper = start.compare(end) <= 0 ? end : start;
+    if (day.compare(lower) < 0 || day.compare(upper) > 0) return void 0;
+    if (day.compare(start) === 0 || day.compare(end) === 0) return "is-range-preview is-range-preview-end";
+    return "is-range-preview";
+  };
+  const updateRangeHover = (event) => {
+    event.stopPropagation();
+    const target = event.target.closest("[data-value]");
+    if (target?.hasAttribute("data-outside-range")) return;
+    const rawValue = target?.dataset.value;
+    if (!rawValue) return;
+    try {
+      setRangeHoverValue(parseDate2(rawValue.slice(0, 10)));
+    } catch {
+    }
+  };
+  return /* @__PURE__ */ jsxs5(
+    DatePicker.Root,
+    {
+      className: `rvg-date-editor${isDateTime ? " is-date-time" : ""}${isRange ? " has-range-selection" : ""}${editorType === "date-range" ? " is-date-range" : ""}`,
+      style,
+      locale,
+      value: selectedDates,
+      defaultOpen: true,
+      openOnClick: true,
+      startOfWeek: 1,
+      selectionMode: isRange ? "range" : "single",
+      numOfMonths: 1,
+      defaultView: initialView,
+      minView: initialView,
+      maxView: initialView,
+      closeOnSelect: !isDateTime,
+      positioning: { placement: "bottom-start" },
+      onValueChange: (details) => {
+        if (details.value.length === 0) return;
+        const next = details.value.map(formatSelectedValue).join(" ~ ");
+        onChange(next);
+        if (!isDateTime && (!isRange || details.value.length === 2)) onCommit(next);
+      },
+      children: [
+        /* @__PURE__ */ jsxs5(DatePicker.Control, { children: [
+          /* @__PURE__ */ jsx5(
+            "input",
+            {
+              className: "rvg-date-value",
+              value: isRange ? draft : parts[0] ?? "",
+              autoFocus: true,
+              onChange: (event) => onChange(event.target.value),
+              onKeyDown: (event) => {
+                event.stopPropagation();
+                if (event.key === "Enter" && !isDateTime) onCommit();
+                if (event.key === "Escape") onCancel();
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx5(DatePicker.Trigger, { "aria-label": labels.selectDate, children: /* @__PURE__ */ jsx5(CalendarIcon, {}) })
+        ] }),
+        /* @__PURE__ */ jsx5(Portal2, { children: /* @__PURE__ */ jsx5(DatePicker.Positioner, { children: /* @__PURE__ */ jsxs5(DatePicker.Content, { className: `rvg-date-content${isDateTime ? " is-date-time" : ""}${isRange ? " has-range-selection" : ""}${editorType === "date-range" ? " is-date-range" : ""}`, children: [
+          /* @__PURE__ */ jsx5(DatePicker.Context, { children: (datePicker) => /* @__PURE__ */ jsx5(DatePicker.View, { className: `rvg-date-view-${initialView}`, view: initialView, children: editorType === "date-range" ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+            /* @__PURE__ */ jsxs5(DatePicker.ViewControl, { className: "rvg-date-range-control", children: [
+              /* @__PURE__ */ jsx5("button", { type: "button", className: "rvg-year-step", "aria-label": labels.previousYear, onClick: () => datePicker.setFocusedValue(datePicker.visibleRange.start.subtract({ years: 1 })), children: /* @__PURE__ */ jsx5(YearStepIcon, { direction: "previous" }) }),
+              /* @__PURE__ */ jsx5("button", { type: "button", "aria-label": labels.previousMonth, onClick: () => datePicker.setFocusedValue(datePicker.visibleRange.start.subtract({ months: 1 })), children: /* @__PURE__ */ jsx5(MonthStepIcon, { direction: "previous" }) }),
+              [0, 1].map((index) => {
+                const offset = datePicker.getOffset({ months: index });
+                return /* @__PURE__ */ jsx5("strong", { children: datePicker.format(offset.visibleRange.start, { year: "numeric", month: "long" }) }, index);
+              }),
+              /* @__PURE__ */ jsx5("button", { type: "button", "aria-label": labels.nextMonth, onClick: () => datePicker.setFocusedValue(datePicker.visibleRange.start.add({ months: 1 })), children: /* @__PURE__ */ jsx5(MonthStepIcon, { direction: "next" }) }),
+              /* @__PURE__ */ jsx5("button", { type: "button", className: "rvg-year-step", "aria-label": labels.nextYear, onClick: () => datePicker.setFocusedValue(datePicker.visibleRange.start.add({ years: 1 })), children: /* @__PURE__ */ jsx5(YearStepIcon, { direction: "next" }) })
+            ] }),
+            /* @__PURE__ */ jsx5("div", { className: "rvg-date-range-months", children: [0, 1].map((index) => {
+              const offset = datePicker.getOffset({ months: index });
+              return /* @__PURE__ */ jsxs5(DatePicker.Table, { onPointerMoveCapture: updateRangeHover, onPointerLeave: () => setRangeHoverValue(void 0), children: [
+                /* @__PURE__ */ jsx5(DatePicker.TableHead, { children: /* @__PURE__ */ jsx5(DatePicker.TableRow, { children: datePicker.weekDays.map((day) => /* @__PURE__ */ jsx5(DatePicker.TableHeader, { children: day.narrow }, day.short)) }) }),
+                /* @__PURE__ */ jsx5(DatePicker.TableBody, { children: offset.weeks.map((week, weekIndex) => /* @__PURE__ */ jsx5(DatePicker.TableRow, { children: week.map((day) => /* @__PURE__ */ jsx5(DatePicker.TableCell, { value: day, visibleRange: offset.visibleRange, children: /* @__PURE__ */ jsx5(DatePicker.TableCellTrigger, { className: rangePreviewClass(day, offset.visibleRange.start), children: day.day }) }, day.toString())) }, weekIndex)) })
+              ] }, index);
+            }) })
+          ] }) : /* @__PURE__ */ jsxs5(Fragment, { children: [
+            /* @__PURE__ */ jsxs5(DatePicker.ViewControl, { className: initialView === "day" ? "rvg-date-day-control" : void 0, children: [
+              initialView === "day" && /* @__PURE__ */ jsx5("button", { type: "button", className: "rvg-year-step", "aria-label": labels.previousYear, onClick: () => datePicker.setFocusedValue(datePicker.focusedValue.subtract({ years: 1 })), children: /* @__PURE__ */ jsx5(YearStepIcon, { direction: "previous" }) }),
+              /* @__PURE__ */ jsx5(DatePicker.PrevTrigger, { "aria-label": labels.previousPage, children: /* @__PURE__ */ jsx5(MonthStepIcon, { direction: "previous" }) }),
+              /* @__PURE__ */ jsx5(DatePicker.ViewTrigger, { children: /* @__PURE__ */ jsx5(DatePicker.RangeText, {}) }),
+              /* @__PURE__ */ jsx5(DatePicker.NextTrigger, { "aria-label": labels.nextPage, children: /* @__PURE__ */ jsx5(MonthStepIcon, { direction: "next" }) }),
+              initialView === "day" && /* @__PURE__ */ jsx5("button", { type: "button", className: "rvg-year-step", "aria-label": labels.nextYear, onClick: () => datePicker.setFocusedValue(datePicker.focusedValue.add({ years: 1 })), children: /* @__PURE__ */ jsx5(YearStepIcon, { direction: "next" }) })
+            ] }),
+            initialView === "day" && /* @__PURE__ */ jsxs5(DatePicker.Table, { onPointerMoveCapture: isRange ? updateRangeHover : void 0, onPointerLeave: isRange ? () => setRangeHoverValue(void 0) : void 0, children: [
+              /* @__PURE__ */ jsx5(DatePicker.TableHead, { children: /* @__PURE__ */ jsx5(DatePicker.TableRow, { children: datePicker.weekDays.map((day) => /* @__PURE__ */ jsx5(DatePicker.TableHeader, { children: day.narrow }, day.short)) }) }),
+              /* @__PURE__ */ jsx5(DatePicker.TableBody, { children: datePicker.weeks.map((week, weekIndex) => /* @__PURE__ */ jsx5(DatePicker.TableRow, { children: week.map((day) => /* @__PURE__ */ jsx5(DatePicker.TableCell, { value: day, children: /* @__PURE__ */ jsx5(DatePicker.TableCellTrigger, { className: isRange ? rangePreviewClass(day, datePicker.visibleRange.start) : void 0, children: day.day }) }, day.toString())) }, weekIndex)) })
+            ] }),
+            initialView === "month" && /* @__PURE__ */ jsx5(DatePicker.Table, { columns: 4, children: /* @__PURE__ */ jsx5(DatePicker.TableBody, { children: datePicker.getMonthsGrid({ columns: 4, format: "short" }).map((months, rowIndex) => /* @__PURE__ */ jsx5(DatePicker.TableRow, { children: months.map((month) => /* @__PURE__ */ jsx5(DatePicker.TableCell, { value: month.value, children: /* @__PURE__ */ jsx5(DatePicker.TableCellTrigger, { children: month.label }) }, month.value)) }, rowIndex)) }) }),
+            initialView === "year" && /* @__PURE__ */ jsx5(DatePicker.Table, { columns: 4, children: /* @__PURE__ */ jsx5(DatePicker.TableBody, { children: datePicker.getYearsGrid({ columns: 4 }).map((years, rowIndex) => /* @__PURE__ */ jsx5(DatePicker.TableRow, { children: years.map((year) => /* @__PURE__ */ jsx5(DatePicker.TableCell, { value: year.value, children: /* @__PURE__ */ jsx5(DatePicker.TableCellTrigger, { children: year.label }) }, year.value)) }, rowIndex)) }) })
+          ] }) }) }),
+          isDateTime && /* @__PURE__ */ jsx5(DateTimePanel, { values: parts, labels, showSeconds: timeFormatHasSeconds(editorFormat, draft), onChange: (nextParts) => onChange(nextParts.join(" ~ ")) }),
+          isDateTime && /* @__PURE__ */ jsx5("div", { className: "rvg-date-footer", children: /* @__PURE__ */ jsx5("button", { type: "button", disabled: isRange ? parts.length < 2 || parts.some((part) => !part) : !parts[0], onClick: () => onCommit(), children: labels.confirm }) })
+        ] }) }) })
+      ]
+    }
+  );
+}
+// src/components/editors/TextEditor.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function TextEditor({ value, type, style, labels, onChange, onCommit, onCancel }) {
+  const handleKeyDown = (event) => {
+    event.stopPropagation();
+    if (event.key === "Enter") onCommit();
+    if (event.key === "Escape") onCancel();
+  };
+  return /* @__PURE__ */ jsxs6("div", { className: "rvg-native-editor has-clear", style, children: [
+    /* @__PURE__ */ jsx6(
+      "input",
+      {
+        type,
+        value,
+        autoFocus: true,
+        onChange: (event) => onChange(event.target.value),
+        onBlur: () => onCommit(),
+        onKeyDown: handleKeyDown
+      }
+    ),
+    value && /* @__PURE__ */ jsx6(
+      "button",
+      {
+        type: "button",
+        className: "rvg-clear-trigger",
+        "aria-label": labels.clearContent,
+        onPointerDown: (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+        },
+        onClick: () => {
+          onChange("");
+          onCommit("");
+        },
+        children: /* @__PURE__ */ jsx6(ClearValueIcon, {})
+      }
+    )
+  ] });
+}
+// src/icons/domIcons.ts
+function createRowDragHandleSvg() {
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.setAttribute("viewBox", "0 0 16 16");
+  for (const [cx, cy] of [[5, 4], [11, 4], [5, 8], [11, 8], [5, 12], [11, 12]]) {
+    const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+    circle.setAttribute("cx", String(cx));
+    circle.setAttribute("cy", String(cy));
+    circle.setAttribute("r", "1");
+    svg.appendChild(circle);
+  }
+  return svg;
+}
+// src/Table.tsx
+import { draggable, dropTargetForElements } from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import { setCustomNativeDragPreview } from "@atlaskit/pragmatic-drag-and-drop/element/set-custom-native-drag-preview";
+import { attachClosestEdge } from "@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge";
+// src/core/format.ts
+function getDisplayLabel(column, row, rowIndex) {
+  const value = column.dataIndex === void 0 ? void 0 : row[column.dataIndex];
+  if (column.formatter) return column.formatter(value, row, rowIndex);
+  if (value == null) return "";
+  const label = String(value);
+  if (column.editor?.type === "date-time" || column.editor?.type === "date-time-range") {
+    return label.replace(/(\d{4}[-/]\d{2}[-/]\d{2})T(?=\d{2}:\d{2})/g, "$1 ");
+  }
+  return label;
+}
+// src/core/layout.ts
+var DEFAULT_COLUMN_WIDTH = 140;
+function isDataColumn(column) {
+  return !column.rowSelection && !column.rowDragHandle && !column.rowNumber;
+}
+function isColumnSortable(column) {
+  return isDataColumn(column) && column.sortable !== false;
+}
+function isColumnFilterable(column) {
+  return isDataColumn(column) && column.filterable !== false;
+}
+function getHeaderTitleRequiredWidth(column, titleWidth) {
+  const minimumReadableTitleWidth = Math.min(Math.ceil(titleWidth), 28);
+  return minimumReadableTitleWidth + (column.align === "center" ? 20 : 22);
+}
+function getVisibleHeaderActions(column, width, columnDraggable = false, titleWidth = 26) {
+  const capacity = Math.max(0, Math.floor((width - getHeaderTitleRequiredWidth(column, titleWidth)) / 18));
+  const candidates = [
+    isColumnFilterable(column) ? "filter" : null,
+    isColumnSortable(column) ? "sort" : null,
+    columnDraggable ? "drag" : null
+  ].filter((action) => action !== null);
+  const visible = new Set(candidates.slice(Math.max(0, candidates.length - capacity)));
+  return { filter: visible.has("filter"), sort: visible.has("sort"), drag: visible.has("drag") };
+}
+function getMinimumColumnWidth(column, columnDraggable = false) {
+  if (column.rowDragHandle) return 36;
+  if (column.rowSelection || column.rowNumber) return 44;
+  return 60;
+}
+function buildColumnMetrics(columns, columnDraggable = false) {
+  let left = 0;
+  return columns.map((column) => {
+    const width = Math.max(getMinimumColumnWidth(column, columnDraggable), column.width ?? DEFAULT_COLUMN_WIDTH);
+    const metric = { left, width, right: left + width };
+    left += width;
+    return metric;
+  });
+}
+function lowerBound(metrics, value) {
+  let low = 0;
+  let high = metrics.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (metrics[middle].right <= value) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+function getViewportRange(scrollLeft, scrollTop, viewportWidth, viewportHeight, rowCount, rowHeight, metrics, overscan) {
+  const rowStart = Math.max(0, Math.floor(scrollTop / rowHeight) - overscan);
+  const rowEnd = Math.min(rowCount, Math.ceil((scrollTop + viewportHeight) / rowHeight) + overscan);
+  const columnStart = Math.max(0, lowerBound(metrics, scrollLeft) - overscan);
+  const visibleEnd = lowerBound(metrics, scrollLeft + viewportWidth);
+  const columnEnd = Math.min(metrics.length, visibleEnd + 1 + overscan);
+  return { rowStart, rowEnd, columnStart, columnEnd };
+}
+function hitTestColumn(metrics, contentX) {
+  const index = lowerBound(metrics, contentX);
+  return index < metrics.length ? index : -1;
+}
+// src/core/render.ts
+var getCellCoordKey = (rowIndex, columnIndex) => `${rowIndex}:${columnIndex}`;
+var COLORS = {
+  background: "#ffffff",
+  header: "#f5f6f7",
+  grid: "#e3e6e8",
+  text: "#202124",
+  muted: "#5f6368",
+  selection: "#1677ff",
+  selectionFill: "#edf4ff",
+  axisSelectionFill: "#e8f2ff",
+  rowHoverFill: "#f6f9fc",
+  editedFill: "#fff1b8",
+  insertedFill: "#c8ead4",
+  stripe: "#fafbfc"
+};
+function ellipsizeText(context, text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  if (context.measureText(text).width <= maxWidth) return text;
+  const ellipsis = "...";
+  const ellipsisWidth = context.measureText(ellipsis).width;
+  if (ellipsisWidth >= maxWidth) return "";
+  let start = 0;
+  let end = text.length;
+  while (start < end) {
+    const middle = Math.ceil((start + end) / 2);
+    const candidate = `${text.slice(0, middle)}${ellipsis}`;
+    if (context.measureText(candidate).width <= maxWidth) start = middle;
+    else end = middle - 1;
+  }
+  return `${text.slice(0, start)}${ellipsis}`;
+}
+function paintGrid(options) {
+  const { context: ctx, width, height, pixelRatio, scrollLeft, scrollTop, rowHeight, headerHeight, fixedHeader, verticalBorderless, striped, columnDraggable, sortState, filterValues, hoveredHeaderAction, rows, columns, metrics, range, selection, editing, hoveredRowIndex, selectionRange, selectedRowKeys, selectedColumnKeys, highlightEditedCells, highlightInsertedRows, insertedRowKeys, editedCellKeys, cellAnnotations, getRowKey, rowDragPreview } = options;
+  const colors = { ...COLORS, ...options.colors };
+  const bodyTop = options.bodyTop ?? headerHeight;
+  const getCellSpan = (rowIndex, columnIndex) => options.cellSpans.get(getCellCoordKey(rowIndex, columnIndex));
+  const getCellWidth = (columnIndex, colSpan) => {
+    let cellWidth = 0;
+    for (let index = columnIndex; index < Math.min(columns.length, columnIndex + colSpan); index += 1) {
+      cellWidth += metrics[index]?.width ?? 0;
+    }
+    return cellWidth;
+  };
+  ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = colors.background;
+  ctx.fillRect(0, 0, width, height);
+  ctx.font = "13px Inter, ui-sans-serif, system-ui, sans-serif";
+  ctx.textBaseline = "middle";
+  const leftFixedWidth = columns.reduce((value, column, index) => column.fixed === "left" ? Math.max(value, metrics[index].right) : value, 0);
+  const rightFixedWidth = columns.reduce((value, column, index) => column.fixed === "right" ? value + metrics[index].width : value, 0);
+  const rightFixedLeft = width - rightFixedWidth;
+  const rightOffsets = /* @__PURE__ */ new Map();
+  let rightOffset = 0;
+  for (let index = columns.length - 1; index >= 0; index -= 1) {
+    if (columns[index].fixed !== "right") continue;
+    rightOffsets.set(index, rightOffset);
+    rightOffset += metrics[index].width;
+  }
+  const getColumnX = (index) => {
+    return columns[index].fixed === "left" ? metrics[index].left : columns[index].fixed === "right" ? width - (rightOffsets.get(index) ?? 0) - metrics[index].width : metrics[index].left - scrollLeft;
+  };
+  const paintBodyColumns = (layer) => {
+    const rowStart = Math.max(0, range.rowStart - Math.max(0, options.maxRowSpan - 1));
+    for (let rowIndex = rowStart; rowIndex < range.rowEnd; rowIndex += 1) {
+      if (rowDragPreview?.sourceIndex === rowIndex) continue;
+      const shift = rowDragPreview ? rowDragPreview.sourceIndex < rowDragPreview.targetIndex ? rowIndex > rowDragPreview.sourceIndex && rowIndex <= rowDragPreview.targetIndex ? -rowHeight : 0 : rowIndex >= rowDragPreview.targetIndex && rowIndex < rowDragPreview.sourceIndex ? rowHeight : 0 : 0;
+      const y = bodyTop + rowIndex * rowHeight - scrollTop + shift;
+      const row = rows[rowIndex];
+      const rowKey = getRowKey(row, rowIndex);
+      for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+        if (layer === "scroll" ? columns[columnIndex].fixed !== void 0 : columns[columnIndex].fixed !== layer) continue;
+        if (layer === "scroll" && (columnIndex < range.columnStart || columnIndex >= range.columnEnd)) continue;
+        const metric = metrics[columnIndex];
+        const x = getColumnX(columnIndex);
+        const column = columns[columnIndex];
+        const span = getCellSpan(rowIndex, columnIndex);
+        if (span && (span.rowIndex !== rowIndex || span.columnIndex !== columnIndex)) continue;
+        const rowSpan = span?.rowSpan ?? 1;
+        const colSpan = span?.colSpan ?? 1;
+        const cellWidth = getCellWidth(columnIndex, colSpan);
+        const cellHeight = rowHeight * rowSpan;
+        const rangeRowStart = selectionRange ? Math.min(selectionRange.anchor.rowIndex, selectionRange.focus.rowIndex) : -1;
+        const rangeRowEnd = selectionRange ? Math.max(selectionRange.anchor.rowIndex, selectionRange.focus.rowIndex) : -1;
+        const rangeColumnStart = selectionRange ? Math.min(selectionRange.anchor.columnIndex, selectionRange.focus.columnIndex) : -1;
+        const rangeColumnEnd = selectionRange ? Math.max(selectionRange.anchor.columnIndex, selectionRange.focus.columnIndex) : -1;
+        const isRangeCell = !column.rowDragHandle && !column.rowSelection && !column.rowNumber && rowIndex >= rangeRowStart && rowIndex <= rangeRowEnd && columnIndex >= rangeColumnStart && columnIndex <= rangeColumnEnd;
+        if (layer !== "scroll" || striped && rowIndex % 2 === 1) {
+          ctx.fillStyle = striped && rowIndex % 2 === 1 ? colors.stripe : colors.background;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        if (selectedRowKeys.has(rowKey) || selectedColumnKeys.has(column.key)) {
+          ctx.fillStyle = colors.axisSelectionFill;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        if (hoveredRowIndex === rowIndex) {
+          ctx.fillStyle = colors.rowHoverFill;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        if (highlightInsertedRows && insertedRowKeys.has(rowKey)) {
+          ctx.fillStyle = colors.insertedFill;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        const isSelectedCell = !column.rowDragHandle && !column.rowSelection && !column.rowNumber && selection?.rowIndex === rowIndex && selection.columnIndex === columnIndex && selection.rowKey === rowKey && selection.columnKey === column.key;
+        const annotation = cellAnnotations.get(`${typeof rowKey}:${String(rowKey)}\0${column.key}`);
+        const rawValue = column.dataIndex === void 0 ? void 0 : row[column.dataIndex];
+        const cellStyle = column.cellStyle?.(rawValue, row, rowIndex);
+        if (!isSelectedCell && !isRangeCell && cellStyle?.backgroundColor) {
+          ctx.fillStyle = cellStyle.backgroundColor;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        if (highlightEditedCells && !insertedRowKeys.has(rowKey) && !isSelectedCell && editedCellKeys.has(`${typeof rowKey}:${String(rowKey)}\0${column.key}`)) {
+          ctx.fillStyle = colors.editedFill;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        if (isSelectedCell || isRangeCell) {
+          ctx.fillStyle = colors.selectionFill;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        if (annotation?.type === "background") {
+          ctx.fillStyle = annotation.color;
+          ctx.fillRect(x, y, cellWidth, cellHeight);
+        }
+        ctx.fillStyle = colors.grid;
+        if (!verticalBorderless) ctx.fillRect(x + cellWidth - 1, y, 1, cellHeight);
+        if (!options.suppressLastRowBottomBorder || rowIndex !== rows.length - 1) {
+          ctx.fillRect(x, y + cellHeight - 1, cellWidth, 1);
+        }
+        if (rowSpan > 1) {
+          const mergedFill = annotation?.type === "background" ? annotation.color : isSelectedCell || isRangeCell ? colors.selectionFill : highlightEditedCells && !insertedRowKeys.has(rowKey) && editedCellKeys.has(`${typeof rowKey}:${String(rowKey)}\0${column.key}`) ? colors.editedFill : highlightInsertedRows && insertedRowKeys.has(rowKey) ? colors.insertedFill : hoveredRowIndex === rowIndex ? colors.rowHoverFill : selectedRowKeys.has(rowKey) || selectedColumnKeys.has(column.key) ? colors.axisSelectionFill : cellStyle?.backgroundColor ?? (striped && rowIndex % 2 === 1 ? colors.stripe : colors.background);
+          ctx.fillStyle = mergedFill;
+          for (let offset = 1; offset < rowSpan; offset += 1) {
+            ctx.fillRect(x, y + offset * rowHeight - 1, cellWidth, 2);
+          }
+        }
+        if (colSpan > 1 && !verticalBorderless) {
+          const mergedFill = annotation?.type === "background" ? annotation.color : isSelectedCell || isRangeCell ? colors.selectionFill : highlightEditedCells && !insertedRowKeys.has(rowKey) && editedCellKeys.has(`${typeof rowKey}:${String(rowKey)}\0${column.key}`) ? colors.editedFill : highlightInsertedRows && insertedRowKeys.has(rowKey) ? colors.insertedFill : hoveredRowIndex === rowIndex ? colors.rowHoverFill : selectedRowKeys.has(rowKey) || selectedColumnKeys.has(column.key) ? colors.axisSelectionFill : cellStyle?.backgroundColor ?? (striped && rowIndex % 2 === 1 ? colors.stripe : colors.background);
+          ctx.fillStyle = mergedFill;
+          let offsetLeft = 0;
+          for (let offset = 1; offset < colSpan; offset += 1) {
+            offsetLeft += metrics[columnIndex + offset - 1]?.width ?? 0;
+            ctx.fillRect(x + offsetLeft - 1, y, 2, cellHeight);
+          }
+        }
+        if (isRangeCell) {
+          ctx.fillStyle = colors.selection;
+          if (rowIndex === rangeRowStart) ctx.fillRect(x, y, cellWidth, 2);
+          if (rowIndex === rangeRowEnd) ctx.fillRect(x, y + cellHeight - 2, cellWidth, 2);
+          if (columnIndex === rangeColumnStart) ctx.fillRect(x, y, 2, cellHeight);
+          if (columnIndex === rangeColumnEnd) ctx.fillRect(x + cellWidth - 2, y, 2, cellHeight);
+        }
+        if (!column.rowDragHandle && !column.rowSelection && !column.renderCell && !(editing?.rowIndex === rowIndex && editing.columnIndex === columnIndex)) {
+          let label = "";
+          try {
+            label = column.rowNumber ? String(rowIndex + 1) : getDisplayLabel(column, row, rowIndex);
+          } catch {
+            label = "Render error";
+          }
+          if (label) {
+            const padding = 10;
+            const textX = column.align === "right" ? x + cellWidth - padding : column.align === "center" ? x + cellWidth / 2 : x + padding;
+            ctx.save();
+            ctx.beginPath();
+            ctx.rect(x + 2, y + 1, Math.max(0, cellWidth - 4), cellHeight - 2);
+            ctx.clip();
+            ctx.fillStyle = cellStyle?.color ?? colors.text;
+            ctx.font = "13px Inter, ui-sans-serif, system-ui, sans-serif";
+            ctx.textAlign = column.align === "right" ? "right" : column.align === "center" ? "center" : "left";
+            ctx.fillText(label, textX, y + cellHeight / 2);
+            ctx.restore();
+          }
+        }
+        if (annotation?.type === "corner") {
+          const cornerTop = y - 1;
+          ctx.fillStyle = annotation.color;
+          ctx.beginPath();
+          ctx.moveTo(x + cellWidth - 10, cornerTop);
+          ctx.lineTo(x + cellWidth, cornerTop);
+          ctx.lineTo(x + cellWidth, y + 10);
+          ctx.closePath();
+          ctx.fill();
+        }
+      }
+    }
+  };
+  paintBodyColumns("scroll");
+  paintBodyColumns("left");
+  paintBodyColumns("right");
+  const headerY = fixedHeader ? 0 : -scrollTop;
+  ctx.fillStyle = colors.header;
+  ctx.fillRect(0, headerY, width, headerHeight);
+  ctx.font = "600 13px Inter, ui-sans-serif, system-ui, sans-serif";
+  const paintHeaderColumns = (layer) => {
+    for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+      if (layer === "scroll" ? columns[columnIndex].fixed !== void 0 : columns[columnIndex].fixed !== layer) continue;
+      if (layer === "scroll" && (columnIndex < range.columnStart || columnIndex >= range.columnEnd)) continue;
+      const metric = metrics[columnIndex];
+      const x = getColumnX(columnIndex);
+      if (layer !== "scroll") {
+        ctx.fillStyle = colors.header;
+        ctx.fillRect(x, headerY, metric.width, headerHeight);
+      }
+      if (selectedColumnKeys.has(columns[columnIndex].key)) {
+        ctx.fillStyle = colors.selectionFill;
+        ctx.fillRect(x, headerY, metric.width, headerHeight);
+      }
+      ctx.fillStyle = colors.grid;
+      if (!verticalBorderless) ctx.fillRect(x + metric.width - 1, headerY, 1, headerHeight);
+      ctx.fillRect(x, headerY + headerHeight - 1, metric.width, 1);
+      const column = columns[columnIndex];
+      if (!column.rowSelection && !column.rowDragHandle && !column.rowNumber && column.title) {
+        ctx.font = "600 13px Inter, ui-sans-serif, system-ui, sans-serif";
+        const titleWidth = ctx.measureText(column.title).width;
+        const visibleActions = getVisibleHeaderActions(column, metric.width, columnDraggable, titleWidth);
+        const actionWidth = (Number(visibleActions.drag) + Number(visibleActions.filter) + Number(visibleActions.sort)) * 18;
+        const contentWidth = Math.max(0, metric.width - actionWidth);
+        const padding = 10;
+        const clipWidth = contentWidth;
+        const centeredTextX = metric.width / 2;
+        const centerTitleWidth = Math.max(0, Math.min(centeredTextX - padding, contentWidth - padding - centeredTextX) * 2);
+        const centerOverflows = column.align === "center" && titleWidth > centerTitleWidth;
+        const titleAlign = centerOverflows ? "right" : column.align;
+        const maxTitleWidth = titleAlign === "center" ? centerTitleWidth : Math.max(0, clipWidth - padding * 2);
+        const title = ellipsizeText(ctx, column.title, maxTitleWidth);
+        const textX = titleAlign === "right" ? x + contentWidth - padding : titleAlign === "center" ? x + centeredTextX : x + padding;
+        ctx.save();
+        ctx.beginPath();
+        ctx.rect(x + 2, headerY + 1, Math.max(0, clipWidth - 4), headerHeight - 2);
+        ctx.clip();
+        ctx.fillStyle = colors.muted;
+        ctx.textAlign = titleAlign === "right" ? "right" : titleAlign === "center" ? "center" : "left";
+        ctx.fillText(title, textX, headerY + headerHeight / 2);
+        ctx.restore();
+      }
+    }
+  };
+  paintHeaderColumns("scroll");
+  paintHeaderColumns("left");
+  paintHeaderColumns("right");
+  if (leftFixedWidth > 0 && scrollLeft > 0) {
+    const shadowWidth = 10;
+    const shadow = ctx.createLinearGradient(leftFixedWidth, 0, leftFixedWidth + shadowWidth, 0);
+    shadow.addColorStop(0, "rgba(5, 5, 5, 0.06)");
+    shadow.addColorStop(1, "rgba(5, 5, 5, 0)");
+    ctx.fillStyle = shadow;
+    ctx.fillRect(leftFixedWidth, 0, shadowWidth, height);
+  }
+  if (rightFixedWidth > 0 && scrollLeft < (metrics[metrics.length - 1]?.right ?? 0) - width) {
+    const shadowWidth = 10;
+    const shadow = ctx.createLinearGradient(rightFixedLeft - shadowWidth, 0, rightFixedLeft, 0);
+    shadow.addColorStop(0, "rgba(5, 5, 5, 0)");
+    shadow.addColorStop(1, "rgba(5, 5, 5, 0.06)");
+    ctx.fillStyle = shadow;
+    ctx.fillRect(rightFixedLeft - shadowWidth, 0, shadowWidth, height);
+  }
+  if (rightFixedWidth > 0 && !verticalBorderless) {
+    ctx.fillStyle = colors.grid;
+    ctx.fillRect(rightFixedLeft - 1, 0, 1, height);
+  }
+  ctx.fillStyle = colors.grid;
+  ctx.fillRect(0, 0, width, 1);
+  if (!verticalBorderless) {
+    ctx.fillRect(0, 0, 1, height);
+    ctx.fillRect(width - 1, 0, 1, height);
+  }
+  if (!options.suppressFrameBottomBorder) ctx.fillRect(0, height - 1, width, 1);
+  if (selectionRange) {
+    const rowStart = Math.min(selectionRange.anchor.rowIndex, selectionRange.focus.rowIndex);
+    const rowEnd = Math.max(selectionRange.anchor.rowIndex, selectionRange.focus.rowIndex);
+    const columnStart = Math.min(selectionRange.anchor.columnIndex, selectionRange.focus.columnIndex);
+    const columnEnd = Math.max(selectionRange.anchor.columnIndex, selectionRange.focus.columnIndex);
+    const top = bodyTop + rowStart * rowHeight - scrollTop;
+    const bottom = bodyTop + (rowEnd + 1) * rowHeight - scrollTop;
+    const clipTop = fixedHeader ? bodyTop : 0;
+    const markerTop = Math.max(top, clipTop);
+    const markerBottom = Math.min(bottom, height);
+    const startX = getColumnX(columnStart);
+    const endX = getColumnX(columnEnd) + metrics[columnEnd].width;
+    const visibleLeft = columns[columnStart].fixed === "left" ? Math.max(0, startX) : Math.max(leftFixedWidth - 1, startX);
+    const visibleRight = columns[columnEnd].fixed === "right" ? Math.min(width, endX) : Math.min(rightFixedLeft, endX);
+    ctx.fillStyle = colors.selection;
+    if (markerBottom > markerTop) {
+      if (columns[columnStart].fixed === void 0 && startX < leftFixedWidth) {
+        ctx.fillRect(Math.max(0, leftFixedWidth - 1), markerTop, 2, markerBottom - markerTop);
+      }
+      if (columns[columnEnd].fixed === void 0 && endX > rightFixedLeft) {
+        ctx.fillRect(Math.max(0, rightFixedLeft - 1), markerTop, 2, markerBottom - markerTop);
+      }
+    }
+    if (visibleRight > visibleLeft) {
+      if (top < clipTop) ctx.fillRect(visibleLeft, clipTop, visibleRight - visibleLeft, 2);
+      if (bottom > height) ctx.fillRect(visibleLeft, height - 2, visibleRight - visibleLeft, 2);
+    } else if (top < clipTop || bottom > height) {
+      const markerX = endX <= leftFixedWidth ? Math.max(0, leftFixedWidth - 1) : Math.max(0, rightFixedLeft - 1);
+      ctx.fillRect(markerX, top < clipTop ? clipTop : height - 2, 2, 2);
+    }
+  }
+  const selectedRow = selection ? rows[selection.rowIndex] : void 0;
+  const hasValidSelection = Boolean(selection && selectedRow && getRowKey(selectedRow, selection.rowIndex) === selection.rowKey);
+  if (selection && hasValidSelection && !selectionRange) {
+    const metric = metrics[selection.columnIndex];
+    if (metric) {
+      const fixedSide = columns[selection.columnIndex].fixed;
+      const isFixed = fixedSide !== void 0;
+      const span = getCellSpan(selection.rowIndex, selection.columnIndex);
+      const selectionWidth = getCellWidth(selection.columnIndex, span?.colSpan ?? 1);
+      const selectionHeight = rowHeight * (span?.rowSpan ?? 1);
+      const x = Math.round(getColumnX(selection.columnIndex));
+      const y = Math.round(bodyTop + selection.rowIndex * rowHeight - scrollTop);
+      const borderWidth = 2;
+      const visibleLeft = fixedSide === "left" ? 0 : leftFixedWidth;
+      const selectionAreaRight = fixedSide === "right" ? width : width - rightFixedWidth;
+      const visibleRight = x + selectionWidth;
+      const visibleBottom = y + selectionHeight;
+      const selectionTop = fixedHeader ? bodyTop : 0;
+      const selectionClipTop = fixedHeader ? Math.max(0, selectionTop - 1) : selectionTop;
+      const hiddenAboveHeader = visibleBottom <= selectionTop;
+      const hiddenBelowViewport = y >= height;
+      const hiddenBehindLeft = !isFixed && visibleRight <= visibleLeft;
+      const hiddenBehindRight = !isFixed && x >= selectionAreaRight;
+      const leftMarkerX = Math.max(0, leftFixedWidth - 1);
+      if ((hiddenAboveHeader || hiddenBelowViewport) && (hiddenBehindLeft || hiddenBehindRight)) {
+        const markerSize = 2;
+        const markerX = hiddenBehindLeft ? leftMarkerX : selectionAreaRight - borderWidth;
+        const markerY = hiddenAboveHeader ? selectionClipTop : height - markerSize;
+        ctx.fillStyle = colors.selection;
+        ctx.fillRect(markerX, markerY, markerSize, markerSize);
+        return;
+      }
+      ctx.save();
+      ctx.beginPath();
+      const clipLeft = fixedSide === "left" ? 0 : Math.max(0, leftFixedWidth - 1);
+      const clipRight = Math.min(width, selectionAreaRight + 1);
+      ctx.rect(clipLeft, selectionClipTop, clipRight - clipLeft, height - selectionClipTop);
+      ctx.clip();
+      ctx.fillStyle = colors.selection;
+      if (hiddenAboveHeader) {
+        const markerLeft = Math.max(x - borderWidth, visibleLeft - 1);
+        const markerRight = Math.min(visibleRight + 1, selectionAreaRight);
+        if (markerRight > markerLeft) ctx.fillRect(markerLeft, selectionClipTop, markerRight - markerLeft, borderWidth);
+      }
+      if (hiddenBelowViewport) {
+        const markerLeft = Math.max(x - borderWidth, visibleLeft - 1);
+        const markerRight = Math.min(visibleRight + 1, selectionAreaRight);
+        if (markerRight > markerLeft) ctx.fillRect(markerLeft, height - borderWidth, markerRight - markerLeft, borderWidth);
+      }
+      if (hiddenBehindLeft || hiddenBehindRight) {
+        const markerTop = Math.max(y - borderWidth, selectionTop);
+        const markerBottom = Math.min(y + selectionHeight + 1, height);
+        const markerX = hiddenBehindLeft ? leftMarkerX : selectionAreaRight - borderWidth;
+        ctx.fillRect(markerX, markerTop, borderWidth, Math.max(0, markerBottom - markerTop));
+      }
+      if (hiddenAboveHeader || hiddenBelowViewport || hiddenBehindLeft || hiddenBehindRight) {
+        ctx.restore();
+        return;
+      }
+      const borderLeft = x <= 0 ? 0 : Math.max(x - borderWidth, visibleLeft - 1);
+      const borderRight = Math.min(x + selectionWidth - 1, selectionAreaRight - borderWidth, width - borderWidth);
+      const borderTop = Math.max(y - borderWidth, selectionClipTop);
+      const borderBottom = Math.min(y + selectionHeight - 1, height - borderWidth);
+      const borderOuterWidth = borderRight + borderWidth - borderLeft;
+      ctx.fillRect(borderLeft, borderTop, borderOuterWidth, borderWidth);
+      ctx.fillRect(borderLeft, borderBottom, borderOuterWidth, borderWidth);
+      ctx.fillRect(borderLeft, borderTop, borderWidth, borderBottom + borderWidth - borderTop);
+      ctx.fillRect(borderRight, borderTop, borderWidth, borderBottom + borderWidth - borderTop);
+      ctx.restore();
+    }
+  }
+}
+// src/hooks/useControllable.ts
+import { useCallback, useState as useState3 } from "react";
+function useControllableKeys(value, defaultValue, onChange) {
+  const [internal, setInternal] = useState3(defaultValue ?? []);
+  const keys = value === void 0 ? internal : value;
+  const setKeys = useCallback((next) => {
+    if (value === void 0) setInternal(next);
+    onChange?.(next);
+  }, [onChange, value]);
+  return [keys, setKeys];
+}
+function useControllableValue(value, defaultValue, onChange) {
+  const [internal, setInternal] = useState3(defaultValue ?? null);
+  const selected = value === void 0 ? internal : value;
+  const setSelected = useCallback((next) => {
+    if (value === void 0) setInternal(next);
+    onChange?.(next);
+  }, [onChange, value]);
+  return [selected, setSelected];
+}
+// src/Table.tsx
+import { Fragment as Fragment3, jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var ANNOTATION_COLORS = ["#f44336", "#ff7a45", "#f5a623", "#f2c94c", "#52c41a", "#13a8a8", "#1677ff", "#597ef7", "#9254de", "#eb2f96"];
+var FALLBACK_HEIGHT = 480;
+var VIRTUAL_OVERSCAN = 4;
+var TOOLTIP_DELAY = 1e3;
+var SUMMARY_CHUNK_SIZE = 5e3;
+var DEFAULT_HEADER_CONTEXT_MENU = ["copy", "select-column"];
+var DEFAULT_CELL_CONTEXT_MENU = ["edit", "copy", "annotation", "|", "select-row", "select-column", "|", "insert-above", "insert-below", "move-up", "move-down", "|", "undo", "clear", "delete-row"];
+var DEFAULT_RANGE_CONTEXT_MENU = ["copy", "annotation", "|", "undo", "clear"];
+var getRowNumberColumnWidth = (rowCount) => {
+  const digits = String(Math.max(1, rowCount)).length;
+  return digits <= 4 ? 44 : 44 + (digits - 4) * 8;
+};
+var createPendingInsertId = () => `table-inserted-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
+var waitForPaint = () => new Promise((resolve) => {
+  requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+});
+function readThemeColor(styles, name, fallback) {
+  return styles.getPropertyValue(name).trim() || fallback;
+}
+function getDefaultRowKey(row, index) {
+  const id = row.id;
+  return typeof id === "string" || typeof id === "number" ? id : index;
+}
+function isEmptyCellValue(value) {
+  return value === null || value === void 0 || value === "";
+}
+var getCellCoordKey2 = (rowIndex, columnIndex) => `${rowIndex}:${columnIndex}`;
+var createEmptyCellSpanLookup = () => ({
+  anchors: /* @__PURE__ */ new Map(),
+  covered: /* @__PURE__ */ new Map(),
+  maxRowSpan: 1
+});
+async function calculateSummaryValues(columns, rows) {
+  const values = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    if (!column.summary) continue;
+    if (typeof column.summary === "function") {
+      values.set(column.key, column.summary(rows, column));
+      await waitForPaint();
+      continue;
+    }
+    if (column.dataIndex === void 0) continue;
+    let total = 0;
+    let hasNumber = false;
+    for (let start = 0; start < rows.length; start += SUMMARY_CHUNK_SIZE) {
+      const end = Math.min(rows.length, start + SUMMARY_CHUNK_SIZE);
+      for (let index = start; index < end; index += 1) {
+        const value = rows[index][column.dataIndex];
+        if (typeof value === "number" && Number.isFinite(value)) {
+          total += value;
+          hasNumber = true;
+        }
+      }
+      await waitForPaint();
+    }
+    if (!hasNumber) continue;
+    values.set(column.key, column.formatter ? column.formatter(total, {}, -1) : total.toLocaleString());
+  }
+  return values;
+}
+function resolveContextMenuSection(section, defaults) {
+  if (section === false) return [];
+  if (Array.isArray(section)) return section;
+  if (section && typeof section === "object") {
+    const excluded = new Set(section.exclude ?? []);
+    return defaults.filter((item) => item === "|" || !excluded.has(item));
+  }
+  return defaults;
+}
+function Table({
+  columns: sourceColumns,
+  rows: sourceRows,
+  rowKey,
+  width = "100%",
+  height = "100%",
+  rowHeight = 36,
+  headerHeight = 40,
+  fixedHeader = true,
+  locale = "zh-CN",
+  verticalBorderless = false,
+  striped = false,
+  highlight,
+  cellSpans = [],
+  loading = false,
+  loadingContent,
+  virtualized = true,
+  tooltip = true,
+  summary = false,
+  rowNumber = true,
+  selectedCell,
+  defaultSelectedCell,
+  onSelectedCellChange,
+  rangeSelection = false,
+  rowSelection,
+  selectedRowKeys,
+  defaultSelectedRowKeys,
+  onSelectedRowKeysChange,
+  columnSelection,
+  selectedColumnKeys,
+  defaultSelectedColumnKeys,
+  onSelectedColumnKeysChange,
+  columnDraggable = true,
+  columnResizable = false,
+  onColumnOrderChange,
+  onColumnResize,
+  rowDraggable = false,
+  onRowOrderChange,
+  onInsertRows,
+  onDeleteRows,
+  sortState = null,
+  onSortStateChange,
+  filterValues = {},
+  onFilterValuesChange,
+  onCellChange,
+  onCellContextMenu,
+  contextMenu: contextMenuConfig = true,
+  emptyContent,
+  className = "",
+  style,
+  ariaLabel = "Data grid"
+}) {
+  const { language, labels } = useMemo(() => resolveGridLocale(locale), [locale]);
+  const hasVerticalBorders = !verticalBorderless;
+  const hasStripedRows = Boolean(striped);
+  const stripedColor = typeof striped === "string" ? striped : void 0;
+  const editedCellsHighlight = highlight?.editedCells ?? false;
+  const insertedRowsHighlight = highlight?.insertedRows ?? false;
+  const highlightsEditedCells = Boolean(editedCellsHighlight);
+  const editedCellHighlightColor = typeof editedCellsHighlight === "string" ? editedCellsHighlight : void 0;
+  const highlightsInsertedRows = Boolean(insertedRowsHighlight);
+  const insertedRowHighlightColor = typeof insertedRowsHighlight === "string" ? insertedRowsHighlight : void 0;
+  const hasCustomLoading = loadingContent !== void 0;
+  const isVirtualized = typeof virtualized === "object" ? virtualized.enabled ?? true : virtualized;
+  const virtualOverscan = typeof virtualized === "object" ? Math.max(0, Math.floor(virtualized.overscan ?? VIRTUAL_OVERSCAN)) : VIRTUAL_OVERSCAN;
+  const tooltipConfig = typeof tooltip === "object" ? { header: tooltip.header ?? true, cell: tooltip.cell ?? true } : { header: tooltip, cell: tooltip };
+  const summaryEnabled = summary === true || typeof summary === "object";
+  const summaryPosition = typeof summary === "object" ? summary.position ?? "bottom" : "bottom";
+  const summaryVerticalBordered = hasVerticalBorders && (typeof summary === "object" ? summary.verticalBordered ?? true : true);
+  const summaryEmptyValue = typeof summary === "object" ? summary.emptyValue ?? "" : "";
+  const contextMenuEnabled = contextMenuConfig !== false;
+  const customContextMenuConfig = typeof contextMenuConfig === "object" ? contextMenuConfig : void 0;
+  const columns = useMemo(() => {
+    const utilityColumns = [];
+    if (rowDraggable) {
+      utilityColumns.push({ key: "__rvg_row_drag__", title: "", width: 36, align: "center", fixed: "left", rowDragHandle: true });
+    }
+    if (rowSelection) {
+      utilityColumns.push({ key: "__rvg_row_selection__", title: "", width: 44, align: "center", fixed: "left", rowSelection: true });
+    }
+    if (rowNumber) {
+      utilityColumns.push({ key: "__rvg_row_number__", title: "#", width: getRowNumberColumnWidth(sourceRows.length), align: "center", fixed: "left", rowNumber: true });
+    }
+    return [...utilityColumns, ...sourceColumns];
+  }, [rowDraggable, rowNumber, rowSelection, sourceColumns, sourceRows.length]);
+  const utilityColumnCount = (rowDraggable ? 1 : 0) + (rowSelection ? 1 : 0) + (rowNumber ? 1 : 0);
+  const canvasRef = useRef2(null);
+  const scrollerRef = useRef2(null);
+  const frameRef = useRef2(null);
+  const textFrameRef = useRef2(null);
+  const toastTimerRef = useRef2(null);
+  const sortDebounceRef = useRef2(null);
+  const headerTooltipTimerRef = useRef2(null);
+  const cellTooltipTimerRef = useRef2(null);
+  const pendingHeaderTooltipKeyRef = useRef2("");
+  const pendingCellTooltipKeyRef = useRef2("");
+  const clickedCellRef = useRef2(null);
+  const rowAnchorRef = useRef2(null);
+  const columnAnchorRef = useRef2(null);
+  const columnDragRef = useRef2(null);
+  const dragGuideRef = useRef2(null);
+  const rowDragGuideRef = useRef2(null);
+  const selectionFocusRef = useRef2(null);
+  const rowByKeyRef = useRef2(/* @__PURE__ */ new Map());
+  const rowIndexByKeyRef = useRef2(/* @__PURE__ */ new Map());
+  const headerIconsRef = useRef2(null);
+  const scrollingHeaderIconsRef = useRef2(null);
+  const scrollingTextRef = useRef2(null);
+  const filterRef = useRef2(null);
+  const contextMenuRef = useRef2(null);
+  const suppressClickRef = useRef2(false);
+  const hasCompletedLoadRef = useRef2(!loading);
+  const columnDragPreviewRef = useRef2(null);
+  const hoveredHeaderActionRef = useRef2(null);
+  const hoveredRowIndexRef = useRef2(null);
+  const [viewport, setViewport] = useState4({ width: 0, height: typeof height === "number" ? height : FALLBACK_HEIGHT });
+  const [horizontalScrollbarHeight, setHorizontalScrollbarHeight] = useState4(0);
+  const resolvedHeight = viewport.height || FALLBACK_HEIGHT;
+  const [scrollPosition, setScrollPosition] = useState4({ left: 0, top: 0 });
+  const scrollRef = useRef2({ left: 0, top: 0 });
+  const [selection, setSelection] = useControllableValue(selectedCell, defaultSelectedCell, onSelectedCellChange);
+  const [selectionRange, setSelectionRange] = useState4(null);
+  const rangeDragRef = useRef2(null);
+  const [rowKeys, setRowKeys] = useControllableKeys(selectedRowKeys, defaultSelectedRowKeys, (keys) => {
+    if (!onSelectedRowKeysChange) return;
+    const missing = new Set(keys.filter((key) => !rowByKeyRef.current.has(key)));
+    if (missing.size > 0) {
+      for (let index = 0; index < rows.length && missing.size > 0; index += 1) {
+        const row = rows[index];
+        const key = getRowKey(row, index);
+        if (missing.delete(key)) {
+          rowByKeyRef.current.set(key, row);
+          rowIndexByKeyRef.current.set(key, index);
+        }
+      }
+    }
+    const entries = keys.flatMap((key) => {
+      const row = rowByKeyRef.current.get(key);
+      const index = rowIndexByKeyRef.current.get(key);
+      return row && index !== void 0 ? [{ row, index }] : [];
+    });
+    onSelectedRowKeysChange(keys, entries.map(({ row }) => row), entries.map(({ index }) => index));
+  });
+  const [columnKeys, setColumnKeys] = useControllableKeys(selectedColumnKeys, defaultSelectedColumnKeys, onSelectedColumnKeysChange);
+  const [editing, setEditing] = useState4(null);
+  const [draft, setDraft] = useState4("");
+  const [rowDragPreview, setRowDragPreview] = useState4(null);
+  useEffect2(() => {
+    if (!loading) hasCompletedLoadRef.current = true;
+  }, [loading]);
+  useEffect2(() => {
+    if (rangeSelection) return;
+    rangeDragRef.current = null;
+    setSelectionRange(null);
+  }, [rangeSelection]);
+  useEffect2(() => () => {
+    if (headerTooltipTimerRef.current !== null) clearTimeout(headerTooltipTimerRef.current);
+    if (cellTooltipTimerRef.current !== null) clearTimeout(cellTooltipTimerRef.current);
+  }, []);
+  const [filterEditor, setFilterEditor] = useState4(null);
+  const [contextMenu, setContextMenu] = useState4(null);
+  const [insertCounts, setInsertCounts] = useState4({ before: 1, after: 1 });
+  const [confirmAction, setConfirmAction] = useState4(null);
+  const [confirmLoading, setConfirmLoading] = useState4(false);
+  const [insertBusy, setInsertBusy] = useState4(false);
+  const [deleteBusy, setDeleteBusy] = useState4(false);
+  const [toast, setToast] = useState4(null);
+  const [hoveredHeaderAction, setHoveredHeaderAction] = useState4(null);
+  const [visibleHeaderTooltip, setVisibleHeaderTooltip] = useState4(null);
+  const [hoveredCellTooltip, setHoveredCellTooltip] = useState4(null);
+  const [displaySortState, setDisplaySortState] = useState4(sortState);
+  const [editedCellKeys, setEditedCellKeys] = useState4(() => /* @__PURE__ */ new Set());
+  const [cellAnnotations, setCellAnnotations] = useState4(() => /* @__PURE__ */ new Map());
+  const [annotationType, setAnnotationType] = useState4("corner");
+  const [annotationColor, setAnnotationColor] = useState4(ANNOTATION_COLORS[0]);
+  const [annotationContent, setAnnotationContent] = useState4("");
+  const [annotationOpen, setAnnotationOpen] = useState4(false);
+  const [annotationPlacement, setAnnotationPlacement] = useState4("right-down");
+  const originalCellValuesRef = useRef2(/* @__PURE__ */ new Map());
+  const [pendingDeletedRowKeys, setPendingDeletedRowKeys] = useState4(() => /* @__PURE__ */ new Set());
+  const [pendingInserts, setPendingInserts] = useState4(() => []);
+  const [insertedRowKeys, setInsertedRowKeys] = useState4(() => /* @__PURE__ */ new Set());
+  const settledPendingInsertIdsRef = useRef2(/* @__PURE__ */ new Set());
+  const getDataRowKey = useCallback2((row, index) => {
+    return typeof rowKey === "function" ? rowKey(row, index) : rowKey ? row[rowKey] : getDefaultRowKey(row, index);
+  }, [rowKey]);
+  const getSourceRowIndexByKey = useCallback2((key, preferredIndex) => {
+    const preferredRow = sourceRows[preferredIndex];
+    if (preferredRow && getDataRowKey(preferredRow, preferredIndex) === key) return preferredIndex;
+    const start = Math.max(0, preferredIndex - 8);
+    const end = Math.min(sourceRows.length, preferredIndex + 9);
+    for (let index = start; index < end; index += 1) {
+      if (getDataRowKey(sourceRows[index], index) === key) return index;
+    }
+    return sourceRows.findIndex((sourceRow, index) => getDataRowKey(sourceRow, index) === key);
+  }, [getDataRowKey, sourceRows]);
+  const rows = useMemo(() => {
+    let next = sourceRows;
+    if (pendingInserts.length > 0) {
+      const activeInserts = pendingInserts.filter((insert) => {
+        if (settledPendingInsertIdsRef.current.has(insert.id)) return false;
+        const isSettled = insert.keys.every((key, offset) => {
+          return getSourceRowIndexByKey(key, insert.index + offset) >= 0;
+        });
+        if (!isSettled) return true;
+        settledPendingInsertIdsRef.current.add(insert.id);
+        return false;
+      });
+      if (activeInserts.length > 0) next = sourceRows.slice();
+      let insertedOffset = 0;
+      activeInserts.slice().sort((left, right) => left.index - right.index).forEach((insert) => {
+        next.splice(Math.min(next.length, insert.index + insertedOffset), 0, ...insert.rows);
+        insertedOffset += insert.rows.length;
+      });
+    }
+    if (pendingDeletedRowKeys.size === 0) return next;
+    return next.filter((row, index) => !pendingDeletedRowKeys.has(getDataRowKey(row, index)));
+  }, [getDataRowKey, pendingDeletedRowKeys, pendingInserts, sourceRows]);
+  useEffect2(() => {
+    if (insertBusy || settledPendingInsertIdsRef.current.size === 0) return;
+    setPendingInserts((current) => {
+      const next = current.filter((insert) => !settledPendingInsertIdsRef.current.has(insert.id));
+      if (next.length === current.length) return current;
+      current.forEach((insert) => {
+        if (!next.includes(insert)) settledPendingInsertIdsRef.current.delete(insert.id);
+      });
+      return next;
+    });
+  }, [insertBusy, pendingInserts]);
+  useEffect2(() => {
+    if (pendingDeletedRowKeys.size === 0) return;
+    setPendingDeletedRowKeys((current) => {
+      if (current.size === 0) return current;
+      const sourceKeys = new Set(sourceRows.map((row, index) => getDataRowKey(row, index)));
+      let changed = false;
+      const next = /* @__PURE__ */ new Set();
+      current.forEach((key) => {
+        if (sourceKeys.has(key)) next.add(key);
+        else changed = true;
+      });
+      return changed ? next : current;
+    });
+  }, [getDataRowKey, pendingDeletedRowKeys.size, sourceRows]);
+  useLayoutEffect2(() => {
+    if (!editing) return;
+    if (selection?.rowKey === editing.rowKey && selection.columnKey === editing.columnKey) return;
+    setEditing(null);
+  }, [editing, selection]);
+  const metrics = useMemo(() => buildColumnMetrics(columns, columnDraggable), [columnDraggable, columns]);
+  const contentWidth = metrics.length > 0 ? metrics[metrics.length - 1].right : 0;
+  const contentHeight = rows.length * rowHeight;
+  const fixedWidth = useMemo(() => columns.reduce((width2, column, index) => column.fixed === "left" ? Math.max(width2, metrics[index].right) : width2, 0), [columns, metrics]);
+  const rightFixedWidth = useMemo(() => columns.reduce((width2, column, index) => column.fixed === "right" ? width2 + metrics[index].width : width2, 0), [columns, metrics]);
+  const rightFixedOffsets = useMemo(() => {
+    const offsets = /* @__PURE__ */ new Map();
+    let offset = 0;
+    for (let index = columns.length - 1; index >= 0; index -= 1) {
+      if (columns[index].fixed !== "right") continue;
+      offsets.set(index, offset);
+      offset += metrics[index].width;
+    }
+    return offsets;
+  }, [columns, metrics]);
+  const hasRowSelectionColumn = useMemo(() => columns.some((column) => column.rowSelection), [columns]);
+  const rowSelectionMode = typeof rowSelection === "object" ? rowSelection.mode ?? "multiple" : "multiple";
+  const hasSummaryRow = useMemo(() => summaryEnabled && columns.some((column) => Boolean(column.summary)), [columns, summaryEnabled]);
+  const topSummaryHeight = hasSummaryRow && summaryPosition === "top" ? rowHeight : 0;
+  const bottomSummaryHeight = hasSummaryRow && summaryPosition === "bottom" ? rowHeight : 0;
+  const bodyTop = headerHeight + topSummaryHeight;
+  const bodyViewportHeight = Math.max(0, resolvedHeight - (fixedHeader ? headerHeight : 0) - topSummaryHeight);
+  const [summaryState, setSummaryState] = useState4(() => ({ columns: null, rows: null, values: /* @__PURE__ */ new Map(), pending: false }));
+  const summaryPending = hasSummaryRow && (loading || summaryState.pending || summaryState.columns !== columns || summaryState.rows !== rows);
+  const summaryValues = hasSummaryRow && summaryState.columns === columns && summaryState.rows === rows ? summaryState.values : /* @__PURE__ */ new Map();
+  useEffect2(() => {
+    let cancelled = false;
+    if (!hasSummaryRow) {
+      setSummaryState((current) => current.columns === null && current.rows === null && current.values.size === 0 && !current.pending ? current : { columns: null, rows: null, values: /* @__PURE__ */ new Map(), pending: false });
+      return () => {
+        cancelled = true;
+      };
+    }
+    setSummaryState((current) => ({
+      columns,
+      rows,
+      values: current.columns === columns && current.rows === rows ? current.values : /* @__PURE__ */ new Map(),
+      pending: true
+    }));
+    if (loading) {
+      return () => {
+        cancelled = true;
+      };
+    }
+    const run = async () => {
+      await waitForPaint();
+      if (cancelled) return;
+      const values = await calculateSummaryValues(columns, rows);
+      if (cancelled) return;
+      setSummaryState({ columns, rows, values, pending: false });
+    };
+    void run();
+    return () => {
+      cancelled = true;
+    };
+  }, [columns, hasSummaryRow, loading, rows]);
+  const domRange = useMemo(() => {
+    if (!isVirtualized) return { rowStart: 0, rowEnd: rows.length, columnStart: 0, columnEnd: columns.length };
+    const currentScroll2 = scrollRef.current;
+    const rowScrollTop = fixedHeader ? currentScroll2.top : Math.max(0, currentScroll2.top - bodyTop);
+    return getViewportRange(currentScroll2.left, rowScrollTop, viewport.width, bodyViewportHeight, rows.length, rowHeight, metrics, virtualOverscan);
+  }, [bodyTop, bodyViewportHeight, columns.length, fixedHeader, isVirtualized, metrics, rowHeight, rows.length, scrollPosition, viewport.width, virtualOverscan]);
+  const getRowKey = useCallback2((row, index) => {
+    const key = getDataRowKey(row, index);
+    rowByKeyRef.current.set(key, row);
+    rowIndexByKeyRef.current.set(key, index);
+    return key;
+  }, [getDataRowKey]);
+  const cellSpanLookup = useMemo(() => {
+    if (cellSpans.length === 0) return createEmptyCellSpanLookup();
+    const rowIndexByKey = /* @__PURE__ */ new Map();
+    rows.forEach((row, index) => rowIndexByKey.set(getRowKey(row, index), index));
+    const columnIndexByKey = new Map(columns.map((column, index) => [column.key, index]));
+    const lookup = createEmptyCellSpanLookup();
+    const occupied = /* @__PURE__ */ new Set();
+    for (const span of cellSpans) {
+      const rowIndex = span.rowKey !== void 0 ? rowIndexByKey.get(span.rowKey) : span.rowIndex;
+      const columnIndex = columnIndexByKey.get(span.columnKey);
+      if (rowIndex === void 0 || columnIndex === void 0) continue;
+      if (rowIndex < 0 || rowIndex >= rows.length) continue;
+      const column = columns[columnIndex];
+      if (column.rowSelection || column.rowDragHandle || column.rowNumber) continue;
+      const fixedSide = column.fixed;
+      let colSpan = Math.max(1, Math.floor(span.colSpan ?? 1));
+      while (colSpan > 1 && (columnIndex + colSpan > columns.length || columns[columnIndex + colSpan - 1]?.fixed !== fixedSide || columns[columnIndex + colSpan - 1]?.rowSelection || columns[columnIndex + colSpan - 1]?.rowDragHandle || columns[columnIndex + colSpan - 1]?.rowNumber)) {
+        colSpan -= 1;
+      }
+      const rowSpan = Math.min(rows.length - rowIndex, Math.max(1, Math.floor(span.rowSpan ?? 1)));
+      if (rowSpan === 1 && colSpan === 1) continue;
+      let overlaps = false;
+      for (let rowOffset = 0; rowOffset < rowSpan && !overlaps; rowOffset += 1) {
+        for (let columnOffset = 0; columnOffset < colSpan; columnOffset += 1) {
+          if (occupied.has(getCellCoordKey2(rowIndex + rowOffset, columnIndex + columnOffset))) {
+            overlaps = true;
+            break;
+          }
+        }
+      }
+      if (overlaps) continue;
+      const resolved = { rowIndex, columnIndex, rowSpan, colSpan };
+      lookup.anchors.set(getCellCoordKey2(rowIndex, columnIndex), resolved);
+      lookup.maxRowSpan = Math.max(lookup.maxRowSpan, rowSpan);
+      for (let rowOffset = 0; rowOffset < rowSpan; rowOffset += 1) {
+        for (let columnOffset = 0; columnOffset < colSpan; columnOffset += 1) {
+          const key = getCellCoordKey2(rowIndex + rowOffset, columnIndex + columnOffset);
+          occupied.add(key);
+          lookup.covered.set(key, resolved);
+        }
+      }
+    }
+    return lookup;
+  }, [cellSpans, columns, getRowKey, rows]);
+  const selectedRowKeySet = useMemo(() => new Set(rowKeys), [rowKeys]);
+  const selectedColumnKeySet = useMemo(() => new Set(columnKeys), [columnKeys]);
+  const insertedRowKeySet = useMemo(() => insertedRowKeys, [insertedRowKeys]);
+  const measureHeaderTitleWidth = useCallback2((columnIndex) => {
+    const title = columns[columnIndex]?.title ?? "";
+    const context = canvasRef.current?.getContext("2d");
+    if (!context) return Array.from(title).reduce((width3, character) => width3 + (/^[\x00-\x7F]$/.test(character) ? 7 : 13), 0);
+    context.save();
+    context.font = "13px Inter, ui-sans-serif, system-ui, sans-serif";
+    const width2 = context.measureText(title).width;
+    context.restore();
+    return width2;
+  }, [columns]);
+  const getCellLabel = useCallback2((rowIndex, columnIndex) => {
+    const row = rows[rowIndex];
+    const column = columns[columnIndex];
+    if (!row || !column || column.rowSelection || column.rowDragHandle) return "";
+    if (column.rowNumber) return String(rowIndex + 1);
+    try {
+      return getDisplayLabel(column, row, rowIndex);
+    } catch {
+      return "Render error";
+    }
+  }, [columns, rows]);
+  const getCellSpan = useCallback2((rowIndex, columnIndex) => cellSpanLookup.covered.get(getCellCoordKey2(rowIndex, columnIndex)), [cellSpanLookup]);
+  const getCellDisplayWidth = useCallback2((columnIndex, colSpan = 1) => {
+    let width2 = 0;
+    for (let index = columnIndex; index < Math.min(columns.length, columnIndex + colSpan); index += 1) {
+      width2 += metrics[index]?.width ?? 0;
+    }
+    return width2;
+  }, [columns.length, metrics]);
+  useEffect2(() => {
+    if (!selection) return;
+    const nextRowIndex = rows.findIndex((row, index) => getRowKey(row, index) === selection.rowKey);
+    const nextColumnIndex = columns.findIndex((column) => column.key === selection.columnKey);
+    if (nextRowIndex < 0 || nextColumnIndex < 0) return;
+    if (nextRowIndex === selection.rowIndex && nextColumnIndex === selection.columnIndex) return;
+    setSelection({ ...selection, rowIndex: nextRowIndex, columnIndex: nextColumnIndex });
+  }, [columns, getRowKey, rows, selection, setSelection]);
+  const draw = useCallback2(() => {
+    frameRef.current = null;
+    const canvas = canvasRef.current;
+    if (!canvas || viewport.width <= 0) return;
+    const ratio = Math.min(window.devicePixelRatio || 1, 2);
+    const displayHeight = resolvedHeight;
+    const physicalWidth = Math.round(viewport.width * ratio);
+    const physicalHeight = Math.round(displayHeight * ratio);
+    if (canvas.width !== physicalWidth) canvas.width = physicalWidth;
+    if (canvas.height !== physicalHeight) canvas.height = physicalHeight;
+    const context = canvas.getContext("2d");
+    if (!context) return;
+    const themeStyles = getComputedStyle(canvas);
+    const themeColors = {
+      background: readThemeColor(themeStyles, "--rvg-color-bg", "#ffffff"),
+      header: readThemeColor(themeStyles, "--rvg-color-header-bg", "#f5f6f7"),
+      grid: readThemeColor(themeStyles, "--rvg-color-grid", "#e3e6e8"),
+      text: readThemeColor(themeStyles, "--rvg-color-text", "#202124"),
+      muted: readThemeColor(themeStyles, "--rvg-color-muted", "#5f6368"),
+      selection: readThemeColor(themeStyles, "--rvg-color-primary", "#1677ff"),
+      selectionFill: readThemeColor(themeStyles, "--rvg-color-selection-fill", "#edf4ff"),
+      axisSelectionFill: readThemeColor(themeStyles, "--rvg-color-axis-selection-fill", "#e8f2ff"),
+      rowHoverFill: readThemeColor(themeStyles, "--rvg-color-row-hover-fill", "#f6f9fc"),
+      editedFill: editedCellHighlightColor ?? readThemeColor(themeStyles, "--rvg-color-edited-fill", "#fff1b8"),
+      insertedFill: insertedRowHighlightColor ?? readThemeColor(themeStyles, "--rvg-color-inserted-fill", "#c8ead4"),
+      stripe: stripedColor ?? readThemeColor(themeStyles, "--rvg-color-stripe", "#fafbfc")
+    };
+    const scroll = scrollRef.current;
+    const rowScrollTop = fixedHeader ? scroll.top : Math.max(0, scroll.top - bodyTop);
+    const range = isVirtualized ? getViewportRange(scroll.left, rowScrollTop, viewport.width, bodyViewportHeight, rows.length, rowHeight, metrics, virtualOverscan) : { rowStart: 0, rowEnd: rows.length, columnStart: 0, columnEnd: columns.length };
+    paintGrid({ context, width: viewport.width, height: resolvedHeight, pixelRatio: ratio, scrollLeft: scroll.left, scrollTop: scroll.top, rowHeight, headerHeight, bodyTop, suppressLastRowBottomBorder: bottomSummaryHeight > 0, suppressFrameBottomBorder: bottomSummaryHeight > 0, fixedHeader, verticalBorderless: !hasVerticalBorders, striped: hasStripedRows, columnDraggable, sortState, filterValues, hoveredHeaderAction: hoveredHeaderActionRef.current, rows, columns, metrics, range, selection, editing, hoveredRowIndex: hoveredRowIndexRef.current, selectionRange, selectedRowKeys: selectedRowKeySet, selectedColumnKeys: selectedColumnKeySet, cellSpans: cellSpanLookup.covered, maxRowSpan: cellSpanLookup.maxRowSpan, highlightEditedCells: highlightsEditedCells, highlightInsertedRows: highlightsInsertedRows, insertedRowKeys: insertedRowKeySet, editedCellKeys, cellAnnotations, getRowKey, rowDragPreview, colors: themeColors });
+  }, [bodyTop, bodyViewportHeight, bottomSummaryHeight, cellAnnotations, cellSpanLookup, columnDraggable, columns, editedCellHighlightColor, editedCellKeys, editing, filterValues, fixedHeader, getRowKey, hasStripedRows, hasVerticalBorders, headerHeight, highlightsEditedCells, highlightsInsertedRows, insertedRowHighlightColor, insertedRowKeySet, isVirtualized, metrics, resolvedHeight, rowDragPreview, rowHeight, rows, selectedColumnKeySet, selectedRowKeySet, selection, selectionRange, sortState, stripedColor, viewport.width, virtualOverscan]);
+  const scheduleDraw = useCallback2(() => {
+    if (frameRef.current === null) frameRef.current = requestAnimationFrame(draw);
+  }, [draw]);
+  useLayoutEffect2(() => {
+    const element = scrollerRef.current;
+    if (!element) return;
+    const update = () => {
+      const measuredHeight = element.clientHeight || (typeof height === "number" ? height : FALLBACK_HEIGHT);
+      setViewport({ width: element.clientWidth, height: measuredHeight });
+      setHorizontalScrollbarHeight(Math.max(0, element.offsetHeight - element.clientHeight));
+    };
+    update();
+    if (typeof ResizeObserver === "undefined") {
+      window.addEventListener("resize", update);
+      return () => window.removeEventListener("resize", update);
+    }
+    const observer = new ResizeObserver(update);
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [height]);
+  useEffect2(() => {
+    scheduleDraw();
+    return () => {
+      if (frameRef.current !== null) {
+        cancelAnimationFrame(frameRef.current);
+        frameRef.current = null;
+      }
+    };
+  }, [scheduleDraw]);
+  useEffect2(() => {
+    setDisplaySortState(sortState);
+  }, [sortState]);
+  useEffect2(() => () => {
+    if (sortDebounceRef.current !== null) clearTimeout(sortDebounceRef.current);
+    if (textFrameRef.current !== null) cancelAnimationFrame(textFrameRef.current);
+    if (toastTimerRef.current !== null) clearTimeout(toastTimerRef.current);
+  }, []);
+  useEffect2(() => {
+    const scroller = scrollerRef.current;
+    if (!scroller) return;
+    const containHorizontalOverscroll = (event) => {
+      if (Math.abs(event.deltaX) <= Math.abs(event.deltaY)) return;
+      const atStart = scroller.scrollLeft <= 0 && event.deltaX < 0;
+      const atEnd = scroller.scrollLeft >= scroller.scrollWidth - scroller.clientWidth - 1 && event.deltaX > 0;
+      if (atStart || atEnd) event.preventDefault();
+    };
+    scroller.addEventListener("wheel", containHorizontalOverscroll, { passive: false });
+    return () => scroller.removeEventListener("wheel", containHorizontalOverscroll);
+  }, []);
+  useEffect2(() => {
+    if (!filterEditor) return;
+    const closeOnOutsidePointer = (event) => {
+      if (!filterRef.current?.contains(event.target)) setFilterEditor(null);
+    };
+    document.addEventListener("pointerdown", closeOnOutsidePointer);
+    return () => document.removeEventListener("pointerdown", closeOnOutsidePointer);
+  }, [filterEditor]);
+  useEffect2(() => {
+    if (!contextMenu) return;
+    const close = (event) => {
+      if (!contextMenuRef.current?.contains(event.target)) setContextMenu(null);
+    };
+    const closeOnEscape = (event) => {
+      if (event.key === "Escape") setContextMenu(null);
+    };
+    document.addEventListener("pointerdown", close);
+    document.addEventListener("keydown", closeOnEscape);
+    return () => {
+      document.removeEventListener("pointerdown", close);
+      document.removeEventListener("keydown", closeOnEscape);
+    };
+  }, [contextMenu]);
+  useEffect2(() => {
+    if (!confirmAction) setConfirmLoading(false);
+  }, [confirmAction]);
+  useEffect2(() => {
+    const scroller = scrollerRef.current;
+    if (!scroller || !insertBusy) return;
+    const left = scroller.scrollLeft;
+    const top = scroller.scrollTop;
+    const lockScroll = () => {
+      scroller.scrollLeft = left;
+      scroller.scrollTop = top;
+    };
+    scroller.addEventListener("scroll", lockScroll);
+    return () => scroller.removeEventListener("scroll", lockScroll);
+  }, [insertBusy]);
+  const handleScroll = useCallback2(() => {
+    const element = scrollerRef.current;
+    if (!element) return;
+    scrollRef.current = { left: element.scrollLeft, top: element.scrollTop };
+    const focus = selectionFocusRef.current;
+    if (focus && selection && !selectionRange) {
+      const row = rows[selection.rowIndex];
+      const metric = metrics[selection.columnIndex];
+      const column = columns[selection.columnIndex];
+      const validSelection = row && metric && column && getRowKey(row, selection.rowIndex) === selection.rowKey;
+      if (!validSelection) {
+        focus.style.display = "none";
+      } else {
+        const rawLeft = column.fixed === "left" ? metric.left : column.fixed === "right" ? viewport.width - (rightFixedOffsets.get(selection.columnIndex) ?? 0) - metric.width : metric.left - element.scrollLeft;
+        const rawTop = bodyTop + selection.rowIndex * rowHeight - element.scrollTop;
+        const span = getCellSpan(selection.rowIndex, selection.columnIndex);
+        const rawRight = rawLeft + getCellDisplayWidth(selection.columnIndex, span?.colSpan ?? 1);
+        const rawBottom = rawTop + rowHeight * (span?.rowSpan ?? 1);
+        const horizontalStart = column.fixed === void 0 ? fixedWidth : 0;
+        const horizontalEnd = column.fixed === void 0 ? viewport.width - rightFixedWidth : viewport.width;
+        const verticalStart = fixedHeader ? bodyTop : 0;
+        if (rawRight <= horizontalStart || rawLeft >= horizontalEnd || rawBottom <= verticalStart || rawTop >= resolvedHeight) {
+          focus.style.display = "none";
+        } else {
+          const borderWidth = 2;
+          const left = Math.round(Math.max(rawLeft - borderWidth, horizontalStart - 1));
+          const right = Math.round(Math.min(rawRight + 1, horizontalEnd, viewport.width));
+          const top = Math.round(Math.max(rawTop - borderWidth, verticalStart - 1));
+          const bottom = Math.round(Math.min(rawBottom + 1, resolvedHeight));
+          focus.style.display = "block";
+          focus.style.left = `${left}px`;
+          focus.style.top = `${top}px`;
+          focus.style.width = `${Math.max(0, right - left)}px`;
+          focus.style.height = `${Math.max(0, bottom - top)}px`;
+        }
+      }
+    }
+    if (textFrameRef.current === null) {
+      textFrameRef.current = requestAnimationFrame(() => {
+        textFrameRef.current = null;
+        setScrollPosition({ ...scrollRef.current });
+      });
+    }
+    if (scrollingTextRef.current) scrollingTextRef.current.style.transform = `translateX(${-element.scrollLeft}px)`;
+    if (scrollingHeaderIconsRef.current) scrollingHeaderIconsRef.current.style.transform = `translateX(${-element.scrollLeft}px)`;
+    if (headerIconsRef.current) headerIconsRef.current.style.transform = `translateY(${fixedHeader ? 0 : -element.scrollTop}px)`;
+    if (hoveredHeaderActionRef.current) {
+      hoveredHeaderActionRef.current = null;
+      setHoveredHeaderAction(null);
+    }
+    setHoveredCellTooltip(null);
+    scheduleDraw();
+    setEditing(null);
+  }, [bodyTop, columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getRowKey, metrics, resolvedHeight, rightFixedOffsets, rightFixedWidth, rowHeight, rows, scheduleDraw, selection, selectionRange, viewport.width]);
+  const locateColumn = useCallback2((clientX) => {
+    const canvas = canvasRef.current;
+    if (!canvas) return -1;
+    const rect = canvas.getBoundingClientRect();
+    const localX = clientX - rect.left;
+    let columnIndex;
+    if (localX < fixedWidth) {
+      columnIndex = hitTestColumn(metrics, localX);
+    } else if (rightFixedWidth > 0 && localX >= viewport.width - rightFixedWidth) {
+      columnIndex = columns.findIndex((column, index) => {
+        if (column.fixed !== "right") return false;
+        const left = viewport.width - (rightFixedOffsets.get(index) ?? 0) - metrics[index].width;
+        return localX >= left && localX < left + metrics[index].width;
+      });
+    } else {
+      columnIndex = hitTestColumn(metrics, localX + scrollRef.current.left);
+    }
+    return columnIndex;
+  }, [columns, fixedWidth, metrics, rightFixedOffsets, rightFixedWidth, viewport.width]);
+  const getDisplayedColumnLeft = useCallback2((columnIndex) => {
+    const metric = metrics[columnIndex];
+    if (columns[columnIndex].fixed === "left") return metric.left;
+    if (columns[columnIndex].fixed === "right") return viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metric.width;
+    return metric.left - scrollRef.current.left;
+  }, [columns, metrics, rightFixedOffsets, viewport.width]);
+  const locateResizeHandle = useCallback2((clientX) => {
+    if (!columnResizable || !canvasRef.current) return -1;
+    const localX = clientX - canvasRef.current.getBoundingClientRect().left;
+    let closest = -1;
+    let distance = 6;
+    for (let index = 0; index < columns.length; index += 1) {
+      if (columns[index].rowSelection || columns[index].rowDragHandle || columns[index].rowNumber) continue;
+      const nextDistance = Math.abs(localX - (getDisplayedColumnLeft(index) + metrics[index].width));
+      if (nextDistance < distance) {
+        distance = nextDistance;
+        closest = index;
+      }
+    }
+    return closest;
+  }, [columnResizable, columns, getDisplayedColumnLeft, metrics]);
+  const locateHeaderAction = useCallback2((clientX, columnIndex) => {
+    if (columnIndex < 0 || !canvasRef.current) return null;
+    const column = columns[columnIndex];
+    if (column.rowSelection || column.rowDragHandle || column.rowNumber) return null;
+    const localX = clientX - canvasRef.current.getBoundingClientRect().left;
+    const columnRight = getDisplayedColumnLeft(columnIndex) + metrics[columnIndex].width;
+    const visibleActions = getVisibleHeaderActions(column, metrics[columnIndex].width, columnDraggable, measureHeaderTitleWidth(columnIndex));
+    let right = columnRight - (visibleActions.drag ? 18 : 4);
+    if (visibleActions.sort) {
+      if (localX >= right - 18 && localX < right) return "sort";
+      right -= 18;
+    }
+    if (visibleActions.filter && localX >= right - 18 && localX < right) return "filter";
+    return null;
+  }, [columnDraggable, columns, getDisplayedColumnLeft, measureHeaderTitleWidth, metrics]);
+  const isHeaderTitleTruncated = useCallback2((columnIndex) => {
+    const canvas = canvasRef.current;
+    if (columnIndex < 0 || !canvas) return false;
+    const column = columns[columnIndex];
+    const metric = metrics[columnIndex];
+    const titleWidth = measureHeaderTitleWidth(columnIndex);
+    const visibleActions = getVisibleHeaderActions(column, metric.width, columnDraggable, titleWidth);
+    const actionWidth = (Number(visibleActions.drag) + Number(visibleActions.filter) + Number(visibleActions.sort)) * 18;
+    return getHeaderTitleRequiredWidth(column, titleWidth) > Math.max(0, metric.width - actionWidth);
+  }, [columnDraggable, columns, measureHeaderTitleWidth, metrics]);
+  const locateHeaderDragHandle = useCallback2((clientX, columnIndex) => {
+    if (!columnDraggable || columnIndex < 0 || !canvasRef.current) return false;
+    const column = columns[columnIndex];
+    if (column.rowSelection || column.rowDragHandle || column.rowNumber) return false;
+    if (!getVisibleHeaderActions(column, metrics[columnIndex].width, columnDraggable, measureHeaderTitleWidth(columnIndex)).drag) return false;
+    const localX = clientX - canvasRef.current.getBoundingClientRect().left;
+    const columnRight = getDisplayedColumnLeft(columnIndex) + metrics[columnIndex].width;
+    return localX >= columnRight - 16 && localX < columnRight - 5;
+  }, [columnDraggable, columns, getDisplayedColumnLeft, measureHeaderTitleWidth, metrics]);
+  const setDragGuide = useCallback2((x) => {
+    const guide = dragGuideRef.current;
+    if (!guide) return;
+    guide.style.display = x === null ? "none" : "block";
+    if (x !== null) guide.style.transform = `translateX(${Math.round(x)}px)`;
+  }, []);
+  const setRowDragGuide = useCallback2((y) => {
+    const guide = rowDragGuideRef.current;
+    if (!guide) return;
+    guide.style.display = y === null ? "none" : "block";
+    if (y !== null) guide.style.transform = `translateY(${Math.round(y)}px)`;
+  }, []);
+  const locateRow = useCallback2((clientY) => {
+    const canvas = canvasRef.current;
+    if (!canvas) return -1;
+    const localY = clientY - canvas.getBoundingClientRect().top;
+    const rowIndex = Math.floor((localY - bodyTop + scrollRef.current.top) / rowHeight);
+    return rowIndex >= 0 && rowIndex < rows.length ? rowIndex : -1;
+  }, [bodyTop, rowHeight, rows.length]);
+  useEffect2(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !columnDraggable && !rowDraggable) return;
+    const getHeaderColumn = (clientX, clientY) => {
+      const rect = canvas.getBoundingClientRect();
+      const headerY = fixedHeader ? 0 : -scrollRef.current.top;
+      const localY = clientY - rect.top;
+      if (localY < headerY || localY >= headerY + headerHeight) return -1;
+      return locateColumn(clientX);
+    };
+    const cleanupDrag = draggable({
+      element: canvas,
+      canDrag: ({ input }) => {
+        const index = getHeaderColumn(input.clientX, input.clientY);
+        if (columnDraggable && index >= 0) return locateHeaderDragHandle(input.clientX, index) && locateResizeHandle(input.clientX) < 0;
+        const columnIndex = locateColumn(input.clientX);
+        return rowDraggable && columnIndex >= 0 && Boolean(columns[columnIndex].rowDragHandle) && locateRow(input.clientY) >= 0;
+      },
+      getInitialData: ({ input }) => {
+        const headerColumn = getHeaderColumn(input.clientX, input.clientY);
+        if (headerColumn < 0) {
+          return { type: "table-row", sourceIndex: locateRow(input.clientY) };
+        }
+        const sourceIndex = headerColumn;
+        columnDragPreviewRef.current = { sourceIndex, targetIndex: sourceIndex };
+        return { type: "table-column", sourceIndex };
+      },
+      onGenerateDragPreview: ({ nativeSetDragImage, source }) => {
+        const sourceIndex = Number(source.data.sourceIndex);
+        setCustomNativeDragPreview({
+          nativeSetDragImage,
+          render: ({ container }) => {
+            const canvasRect = canvas.getBoundingClientRect();
+            if (source.data.type === "table-row") {
+              const preview2 = document.createElement("div");
+              preview2.className = "rvg-row-drag-preview";
+              preview2.style.width = `${canvasRect.width}px`;
+              preview2.style.height = `${rowHeight}px`;
+              const row = rows[sourceIndex];
+              const rowKey2 = getRowKey(row, sourceIndex);
+              columns.forEach((column2, columnIndex) => {
+                const left = getDisplayedColumnLeft(columnIndex);
+                const columnWidth2 = metrics[columnIndex].width;
+                if (left + columnWidth2 <= 0 || left >= canvasRect.width) return;
+                const cell = document.createElement("div");
+                cell.className = "rvg-row-drag-preview-cell";
+                cell.style.left = `${left}px`;
+                cell.style.width = `${columnWidth2}px`;
+                cell.style.justifyContent = column2.align === "right" ? "flex-end" : column2.align === "center" ? "center" : "flex-start";
+                if (column2.rowDragHandle) {
+                  cell.appendChild(createRowDragHandleSvg());
+                } else if (column2.rowSelection) {
+                  const checkbox = document.createElement("span");
+                  checkbox.className = selectedRowKeySet.has(rowKey2) ? "rvg-preview-checkbox is-checked" : "rvg-preview-checkbox";
+                  checkbox.textContent = selectedRowKeySet.has(rowKey2) ? "\u2713" : "";
+                  cell.appendChild(checkbox);
+                } else {
+                  cell.textContent = getCellLabel(sourceIndex, columnIndex);
+                }
+                preview2.appendChild(cell);
+              });
+              container.appendChild(preview2);
+              return () => preview2.remove();
+            }
+            const preview = document.createElement("div");
+            preview.className = "rvg-column-drag-preview";
+            const columnWidth = metrics[sourceIndex].width;
+            preview.style.width = `${columnWidth}px`;
+            preview.style.height = `${canvasRect.height}px`;
+            const column = columns[sourceIndex];
+            const header = document.createElement("div");
+            header.className = "rvg-column-drag-preview-header";
+            header.style.top = `${fixedHeader ? 0 : -scrollRef.current.top}px`;
+            header.style.height = `${headerHeight}px`;
+            header.style.justifyContent = column.align === "right" ? "flex-end" : column.align === "center" ? "center" : "flex-start";
+            header.textContent = column.title;
+            preview.appendChild(header);
+            for (let rowIndex = domRange.rowStart; rowIndex < domRange.rowEnd; rowIndex += 1) {
+              const row = rows[rowIndex];
+              const rowKey2 = getRowKey(row, rowIndex);
+              const cell = document.createElement("div");
+              cell.className = "rvg-column-drag-preview-cell";
+              cell.style.top = `${bodyTop + rowIndex * rowHeight - scrollRef.current.top}px`;
+              cell.style.height = `${rowHeight}px`;
+              cell.style.justifyContent = column.align === "right" ? "flex-end" : column.align === "center" ? "center" : "flex-start";
+              const key = `${typeof rowKey2}:${String(rowKey2)}\0${column.key}`;
+              if (selectedRowKeySet.has(rowKey2) || selectedColumnKeySet.has(column.key)) {
+                cell.classList.add("is-axis-selected");
+              }
+              if (!insertedRowKeys.has(rowKey2) && editedCellKeys.has(key)) cell.classList.add("is-edited");
+              if (selection?.rowKey === rowKey2 && selection.columnKey === column.key) {
+                cell.classList.remove("is-edited");
+                cell.classList.add("is-selected");
+              }
+              cell.textContent = getCellLabel(rowIndex, sourceIndex);
+              preview.appendChild(cell);
+            }
+            container.appendChild(preview);
+            return () => preview.remove();
+          }
+        });
+      },
+      onDragStart: ({ source }) => {
+        suppressClickRef.current = true;
+        canvas.style.cursor = "move";
+        if (source.data.type === "table-row") {
+          const sourceIndex = Number(source.data.sourceIndex);
+          setRowDragPreview({ sourceIndex, targetIndex: sourceIndex });
+        }
+      },
+      onDrag: ({ source, location }) => {
+        const target = location.current.dropTargets[0]?.data;
+        const sourceIndex = Number(source.data.sourceIndex);
+        if (source.data.type === "table-row") {
+          const rawTargetIndex = Number(target?.targetIndex);
+          if (!Number.isInteger(rawTargetIndex)) {
+            setRowDragPreview(null);
+            return setRowDragGuide(null);
+          }
+          const edge2 = target?.rowEdge;
+          let targetIndex2 = rawTargetIndex + (edge2 === "bottom" ? 1 : 0);
+          if (sourceIndex < targetIndex2) targetIndex2 -= 1;
+          targetIndex2 = Math.max(0, Math.min(rows.length - 1, targetIndex2));
+          setRowDragPreview((current) => current?.sourceIndex === sourceIndex && current.targetIndex === targetIndex2 ? current : { sourceIndex, targetIndex: targetIndex2 });
+          setRowDragGuide(bodyTop + rawTargetIndex * rowHeight - scrollRef.current.top + (edge2 === "bottom" ? rowHeight : 0));
+          return;
+        }
+        const targetIndex = Number(target?.targetIndex);
+        if (!Number.isInteger(targetIndex) || columns[targetIndex]?.fixed !== columns[sourceIndex]?.fixed) {
+          setDragGuide(null);
+          return;
+        }
+        const edge = target?.columnEdge;
+        let destinationIndex = targetIndex + (edge === "right" ? 1 : 0);
+        if (sourceIndex < destinationIndex) destinationIndex -= 1;
+        destinationIndex = Math.max(0, Math.min(columns.length - 1, destinationIndex));
+        columnDragPreviewRef.current = { sourceIndex, targetIndex: destinationIndex };
+        const targetLeft = getDisplayedColumnLeft(targetIndex);
+        setDragGuide(edge === "right" ? targetLeft + metrics[targetIndex].width : targetLeft);
+      },
+      onDrop: ({ source, location }) => {
+        const target = location.current.dropTargets[0]?.data;
+        const sourceIndex = Number(source.data.sourceIndex);
+        if (source.data.type === "table-row") {
+          const rawTargetIndex = Number(target?.targetIndex);
+          let targetIndex2 = rawTargetIndex + (target?.rowEdge === "bottom" ? 1 : 0);
+          if (sourceIndex < targetIndex2) targetIndex2 -= 1;
+          targetIndex2 = Math.max(0, Math.min(rows.length - 1, targetIndex2));
+          scrollerRef.current?.classList.add("rvg-row-drop-settling");
+          setRowDragPreview(null);
+          setRowDragGuide(null);
+          canvas.style.cursor = "default";
+          if (Number.isInteger(rawTargetIndex) && sourceIndex !== targetIndex2) onRowOrderChange?.(sourceIndex, targetIndex2);
+          requestAnimationFrame(() => {
+            requestAnimationFrame(() => scrollerRef.current?.classList.remove("rvg-row-drop-settling"));
+          });
+          window.setTimeout(() => {
+            suppressClickRef.current = false;
+          }, 0);
+          return;
+        }
+        const targetIndex = columnDragPreviewRef.current?.targetIndex ?? Number(target?.targetIndex);
+        canvas.style.cursor = "default";
+        setDragGuide(null);
+        columnDragPreviewRef.current = null;
+        if (Number.isInteger(targetIndex) && sourceIndex !== targetIndex && columns[targetIndex]?.fixed === columns[sourceIndex]?.fixed) {
+          onColumnOrderChange?.(sourceIndex - utilityColumnCount, targetIndex - utilityColumnCount);
+        }
+        window.setTimeout(() => {
+          suppressClickRef.current = false;
+        }, 0);
+      }
+    });
+    const cleanupDrop = dropTargetForElements({
+      element: canvas,
+      canDrop: ({ source }) => source.data.type === "table-column" || source.data.type === "table-row",
+      getData: ({ input, element, source }) => {
+        if (source.data.type === "table-row") {
+          const targetIndex2 = locateRow(input.clientY);
+          if (targetIndex2 < 0) return { targetIndex: -1 };
+          const rowTop = bodyTop + targetIndex2 * rowHeight - scrollRef.current.top;
+          const rowEdge = input.clientY - canvas.getBoundingClientRect().top < rowTop + rowHeight / 2 ? "top" : "bottom";
+          return attachClosestEdge({ targetIndex: targetIndex2, rowEdge }, { element, input, allowedEdges: ["top", "bottom"] });
+        }
+        let targetIndex = getHeaderColumn(input.clientX, input.clientY);
+        if (targetIndex < 0) return { targetIndex: -1 };
+        if (columns[targetIndex].rowSelection || columns[targetIndex].rowDragHandle || columns[targetIndex].rowNumber) {
+          const fixedSide = columns[Number(source.data.sourceIndex)]?.fixed;
+          targetIndex = columns.findIndex((column, index) => index > targetIndex && column.fixed === fixedSide && !column.rowSelection && !column.rowDragHandle && !column.rowNumber);
+          if (targetIndex < 0) return { targetIndex: -1 };
+          return { targetIndex, columnEdge: "left" };
+        }
+        const left = getDisplayedColumnLeft(targetIndex);
+        const columnEdge = input.clientX - canvas.getBoundingClientRect().left < left + metrics[targetIndex].width / 2 ? "left" : "right";
+        return attachClosestEdge({ targetIndex, columnEdge }, { element, input, allowedEdges: ["left", "right"] });
+      }
+    });
+    return () => {
+      cleanupDrag();
+      cleanupDrop();
+    };
+  }, [bodyTop, columnDraggable, columns, fixedHeader, getCellLabel, getDisplayedColumnLeft, getRowKey, headerHeight, locateColumn, locateHeaderDragHandle, locateResizeHandle, locateRow, metrics, onColumnOrderChange, onRowOrderChange, rowDraggable, rowHeight, rows, selectedRowKeySet, setDragGuide, setRowDragGuide, utilityColumnCount]);
+  const locateCell = useCallback2((clientX, clientY) => {
+    const canvas = canvasRef.current;
+    if (!canvas) return null;
+    const rect = canvas.getBoundingClientRect();
+    const localY = clientY - rect.top;
+    const contentY = localY + (fixedHeader ? 0 : scrollRef.current.top);
+    if (contentY < bodyTop) return null;
+    const rowIndex = Math.floor((localY - bodyTop + scrollRef.current.top) / rowHeight);
+    const columnIndex = locateColumn(clientX);
+    if (rowIndex < 0 || rowIndex >= rows.length || columnIndex < 0) return null;
+    const span = getCellSpan(rowIndex, columnIndex);
+    const targetRowIndex = span?.rowIndex ?? rowIndex;
+    const targetColumnIndex = span?.columnIndex ?? columnIndex;
+    return {
+      rowIndex: targetRowIndex,
+      columnIndex: targetColumnIndex,
+      rowKey: getRowKey(rows[targetRowIndex], targetRowIndex),
+      columnKey: columns[targetColumnIndex].key
+    };
+  }, [bodyTop, columns, fixedHeader, getCellSpan, getRowKey, locateColumn, rowHeight, rows]);
+  const beginRangeDrag = useCallback2((event) => {
+    if (!rangeSelection) return;
+    if (event.button !== 0 || editing || event.target !== event.currentTarget) return;
+    const cell = locateCell(event.clientX, event.clientY);
+    if (!cell || columns[cell.columnIndex].rowSelection || columns[cell.columnIndex].rowDragHandle || columns[cell.columnIndex].rowNumber) return;
+    rangeDragRef.current = { anchor: cell, moved: false };
+    setSelectionRange(null);
+    event.currentTarget.setPointerCapture(event.pointerId);
+  }, [columns, editing, locateCell, rangeSelection]);
+  const updateRangeDrag = useCallback2((event) => {
+    const drag = rangeDragRef.current;
+    if (!drag) return;
+    const focus = locateCell(event.clientX, event.clientY);
+    if (!focus || columns[focus.columnIndex].rowSelection || columns[focus.columnIndex].rowDragHandle || columns[focus.columnIndex].rowNumber) return;
+    if (focus.rowIndex === drag.anchor.rowIndex && focus.columnIndex === drag.anchor.columnIndex) return;
+    drag.moved = true;
+    event.preventDefault();
+    setSelectionRange((current) => current?.focus.rowIndex === focus.rowIndex && current.focus.columnIndex === focus.columnIndex ? current : { anchor: drag.anchor, focus });
+  }, [columns, locateCell]);
+  const endRangeDrag = useCallback2((event) => {
+    const drag = rangeDragRef.current;
+    if (!drag) return;
+    rangeDragRef.current = null;
+    if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
+    if (!drag.moved) return;
+    suppressClickRef.current = true;
+    setSelection(drag.anchor);
+    scrollerRef.current?.focus({ preventScroll: true });
+  }, [setSelection]);
+  const selectRow = useCallback2((rowIndex, event, forceToggle = false) => {
+    if (!rowSelection) return;
+    const mode = typeof rowSelection === "object" ? rowSelection.mode ?? "multiple" : "multiple";
+    const key = getRowKey(rows[rowIndex], rowIndex);
+    let next;
+    if (mode === "multiple" && event.shiftKey && rowAnchorRef.current !== null) {
+      const start = Math.min(rowAnchorRef.current, rowIndex);
+      const end = Math.max(rowAnchorRef.current, rowIndex);
+      next = rows.slice(start, end + 1).map(getRowKey);
+    } else if (mode === "multiple" && (forceToggle || event.ctrlKey || event.metaKey)) {
+      next = selectedRowKeySet.has(key) ? rowKeys.filter((item) => item !== key) : [...rowKeys, key];
+    } else {
+      next = rowKeys.length === 1 && selectedRowKeySet.has(key) ? [] : [key];
+    }
+    rowAnchorRef.current = rowIndex;
+    setRowKeys(next);
+  }, [getRowKey, rowKeys, rowSelection, rows, selectedRowKeySet, setRowKeys]);
+  const selectColumn = useCallback2((columnIndex, event) => {
+    if (!columnSelection || columnIndex < 0) return;
+    const mode = typeof columnSelection === "object" ? columnSelection.mode ?? "multiple" : "multiple";
+    const key = columns[columnIndex].key;
+    let next;
+    if (mode === "multiple" && event.shiftKey && columnAnchorRef.current !== null) {
+      const start = Math.min(columnAnchorRef.current, columnIndex);
+      const end = Math.max(columnAnchorRef.current, columnIndex);
+      next = columns.slice(start, end + 1).map((column) => column.key);
+    } else if (mode === "multiple") {
+      next = selectedColumnKeySet.has(key) ? columnKeys.filter((item) => item !== key) : [...columnKeys, key];
+    } else {
+      next = columnKeys.length === 1 && selectedColumnKeySet.has(key) ? [] : [key];
+    }
+    columnAnchorRef.current = columnIndex;
+    setColumnKeys(next);
+  }, [columnKeys, columnSelection, columns, selectedColumnKeySet, setColumnKeys]);
+  const toggleColumnFromMenu = useCallback2((columnIndex) => {
+    if (!columnSelection || columnIndex < 0) return;
+    const key = columns[columnIndex].key;
+    const mode = typeof columnSelection === "object" ? columnSelection.mode ?? "multiple" : "multiple";
+    const selected = selectedColumnKeySet.has(key);
+    const next = selected ? columnKeys.filter((value) => value !== key) : mode === "multiple" ? [...columnKeys, key] : [key];
+    columnAnchorRef.current = columnIndex;
+    setColumnKeys(next);
+  }, [columnKeys, columnSelection, columns, selectedColumnKeySet, setColumnKeys]);
+  const revealCell = useCallback2((cell) => {
+    const scroller = scrollerRef.current;
+    const metric = metrics[cell.columnIndex];
+    const column = columns[cell.columnIndex];
+    if (!scroller || !metric || !column) return;
+    let nextLeft = scroller.scrollLeft;
+    let nextTop = scroller.scrollTop;
+    const span = getCellSpan(cell.rowIndex, cell.columnIndex);
+    const colSpan = span?.colSpan ?? 1;
+    const rowSpan = span?.rowSpan ?? 1;
+    const cellWidth = getCellDisplayWidth(cell.columnIndex, colSpan);
+    const horizontalFocusGap = 0;
+    const verticalFocusGap = 0;
+    if (column.fixed === void 0) {
+      if (metric.left - nextLeft < fixedWidth) nextLeft = Math.max(0, metric.left - fixedWidth - horizontalFocusGap);
+      if (metric.left + cellWidth - nextLeft > viewport.width - rightFixedWidth) nextLeft = metric.left + cellWidth - viewport.width + rightFixedWidth + horizontalFocusGap;
+    }
+    const rowTop = (fixedHeader ? 0 : bodyTop) + cell.rowIndex * rowHeight;
+    const rowBottom = rowTop + rowHeight * rowSpan;
+    if (rowTop < nextTop + verticalFocusGap) nextTop = Math.max(0, rowTop - verticalFocusGap);
+    const viewportHeight = scroller.clientHeight;
+    const visibleRowHeight = fixedHeader ? viewportHeight - bodyTop : viewportHeight;
+    if (rowBottom > nextTop + visibleRowHeight - verticalFocusGap) nextTop = rowBottom - visibleRowHeight + verticalFocusGap;
+    if (nextLeft === scroller.scrollLeft && nextTop === scroller.scrollTop) return;
+    scroller.scrollLeft = nextLeft;
+    scroller.scrollTop = nextTop;
+    scrollRef.current = { left: scroller.scrollLeft, top: scroller.scrollTop };
+    scheduleDraw();
+  }, [bodyTop, columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, metrics, rightFixedWidth, rowHeight, scheduleDraw, viewport.width]);
+  const beginEdit = useCallback2((cell) => {
+    const column = columns[cell.columnIndex];
+    if (!column?.editable || column.dataIndex === void 0) return;
+    const value = rows[cell.rowIndex]?.[column.dataIndex];
+    setDraft(value == null ? "" : String(value));
+    const scroller = scrollerRef.current;
+    const metric = metrics[cell.columnIndex];
+    if (!scroller || !metric) {
+      setEditing(cell);
+      return;
+    }
+    let nextLeft = scroller.scrollLeft;
+    let nextTop = scroller.scrollTop;
+    const span = getCellSpan(cell.rowIndex, cell.columnIndex);
+    const colSpan = span?.colSpan ?? 1;
+    const rowSpan = span?.rowSpan ?? 1;
+    const cellWidth = getCellDisplayWidth(cell.columnIndex, colSpan);
+    const horizontalFocusGap = 0;
+    const verticalFocusGap = 0;
+    if (column.fixed === void 0) {
+      if (metric.left - nextLeft < fixedWidth) nextLeft = Math.max(0, metric.left - fixedWidth - horizontalFocusGap);
+      if (metric.left + cellWidth - nextLeft > viewport.width - rightFixedWidth) nextLeft = metric.left + cellWidth - viewport.width + rightFixedWidth + horizontalFocusGap;
+    }
+    const rowTop = (fixedHeader ? 0 : bodyTop) + cell.rowIndex * rowHeight;
+    const rowBottom = rowTop + rowHeight * rowSpan;
+    if (rowTop < nextTop + verticalFocusGap) nextTop = Math.max(0, rowTop - verticalFocusGap);
+    const viewportHeight = scroller.clientHeight;
+    const visibleRowHeight = fixedHeader ? viewportHeight - bodyTop : viewportHeight;
+    if (rowBottom > nextTop + visibleRowHeight - verticalFocusGap) nextTop = rowBottom - visibleRowHeight + verticalFocusGap;
+    const needsScroll = nextLeft !== scroller.scrollLeft || nextTop !== scroller.scrollTop;
+    if (needsScroll) {
+      scroller.scrollLeft = nextLeft;
+      scroller.scrollTop = nextTop;
+      scrollRef.current = { left: scroller.scrollLeft, top: scroller.scrollTop };
+      scheduleDraw();
+      requestAnimationFrame(() => {
+        scrollRef.current = { left: scroller.scrollLeft, top: scroller.scrollTop };
+        scheduleDraw();
+        requestAnimationFrame(() => setEditing(cell));
+      });
+      return;
+    }
+    setEditing(cell);
+  }, [columns, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, metrics, rightFixedWidth, rowHeight, rows, scheduleDraw, viewport.width]);
+  const getCellEditKey = (cell) => `${typeof cell.rowKey}:${String(cell.rowKey)}\0${cell.columnKey}`;
+  const markCellEdited = (cell, previousValue, nextValue) => {
+    const key = getCellEditKey(cell);
+    if (insertedRowKeys.has(cell.rowKey)) {
+      originalCellValuesRef.current.delete(key);
+      setEditedCellKeys((current) => {
+        if (!current.has(key)) return current;
+        const next = new Set(current);
+        next.delete(key);
+        return next;
+      });
+      return;
+    }
+    if (!originalCellValuesRef.current.has(key)) {
+      originalCellValuesRef.current.set(key, String(previousValue ?? ""));
+    }
+    const differsFromOriginal = String(nextValue) !== originalCellValuesRef.current.get(key);
+    setEditedCellKeys((current) => {
+      if (current.has(key) === differsFromOriginal) return current;
+      const next = new Set(current);
+      if (differsFromOriginal) next.add(key);
+      else next.delete(key);
+      return next;
+    });
+  };
+  const commitEdit = useCallback2((nextDraft, close = true) => {
+    if (!editing) return;
+    const committedDraft = nextDraft ?? draft;
+    const column = columns[editing.columnIndex];
+    const row = rows[editing.rowIndex];
+    if (column?.dataIndex !== void 0 && row) {
+      const previousValue = row[column.dataIndex];
+      const committedValue = typeof previousValue === "number" && committedDraft !== "" ? Number(committedDraft) : committedDraft;
+      if (String(previousValue ?? "") === String(committedValue ?? "")) {
+        if (close) setEditing(null);
+        return;
+      }
+      markCellEdited(editing, previousValue, committedValue);
+      onCellChange?.({ ...editing, row, value: committedValue, previousValue });
+    }
+    if (close) setEditing(null);
+  }, [columns, draft, editing, onCellChange, rows]);
+  const renderEditor = () => {
+    if (!editing || !editorStyle) return null;
+    const column = columns[editing.columnIndex];
+    if (column.editor?.type === "select") {
+      return /* @__PURE__ */ jsx7(
+        ChoiceEditor,
+        {
+          value: draft,
+          options: column.editor.options,
+          style: editorStyle,
+          labels,
+          onChange: setDraft,
+          onCommit: (next) => commitEdit(next),
+          onCancel: () => setEditing(null)
+        }
+      );
+    }
+    if (column.editor?.type === "time" || column.editor?.type === "time-range") {
+      return /* @__PURE__ */ jsx7(
+        CompactTimeEditor,
+        {
+          value: draft,
+          range: column.editor.type === "time-range",
+          showSeconds: timeFormatHasSeconds(column.editor.format, draft),
+          style: editorStyle,
+          labels,
+          onChange: setDraft,
+          onCommit: () => commitEdit(),
+          onCancel: () => setEditing(null)
+        }
+      );
+    }
+    if (column.editor && ["date", "date-range", "date-time", "date-time-range", "year", "month"].includes(column.editor.type)) {
+      return /* @__PURE__ */ jsx7(
+        DateEditor,
+        {
+          editor: column.editor,
+          value: draft,
+          style: editorStyle,
+          locale: language,
+          labels,
+          onChange: setDraft,
+          onCommit: (next) => commitEdit(next),
+          onCancel: () => setEditing(null)
+        }
+      );
+    }
+    const row = rows[editing.rowIndex];
+    const cellValue = column.dataIndex === void 0 ? void 0 : row?.[column.dataIndex];
+    return /* @__PURE__ */ jsx7(
+      TextEditor,
+      {
+        value: draft,
+        type: typeof cellValue === "number" ? "number" : "text",
+        style: editorStyle,
+        labels,
+        onChange: setDraft,
+        onCommit: (next) => commitEdit(next),
+        onCancel: () => setEditing(null)
+      }
+    );
+  };
+  const handleKeyDown = useCallback2((event) => {
+    if (editing || !selection) return;
+    if (event.key === "Enter") {
+      event.preventDefault();
+      beginEdit(selection);
+      return;
+    }
+    const delta = event.key === "ArrowUp" ? [-1, 0] : event.key === "ArrowDown" ? [1, 0] : event.key === "ArrowLeft" ? [0, -1] : event.key === "ArrowRight" ? [0, 1] : null;
+    if (!delta) return;
+    event.preventDefault();
+    const targetRowIndex = Math.max(0, Math.min(rows.length - 1, selection.rowIndex + delta[0]));
+    const targetColumnIndex = Math.max(0, Math.min(columns.length - 1, selection.columnIndex + delta[1]));
+    const span = getCellSpan(targetRowIndex, targetColumnIndex);
+    const rowIndex = span?.rowIndex ?? targetRowIndex;
+    const columnIndex = span?.columnIndex ?? targetColumnIndex;
+    const next = { rowIndex, columnIndex, rowKey: getRowKey(rows[rowIndex], rowIndex), columnKey: columns[columnIndex].key };
+    setSelection(next);
+    const scroller = scrollerRef.current;
+    const metric = metrics[columnIndex];
+    if (scroller && metric) {
+      const rowTop = (fixedHeader ? 0 : bodyTop) + rowIndex * rowHeight;
+      const rowBottom = rowTop + rowHeight * (span?.rowSpan ?? 1);
+      const cellWidth = getCellDisplayWidth(columnIndex, span?.colSpan ?? 1);
+      const visibleRowHeight = fixedHeader ? resolvedHeight - bodyTop : resolvedHeight;
+      if (rowTop < scroller.scrollTop) scroller.scrollTop = rowTop;
+      if (rowBottom > scroller.scrollTop + visibleRowHeight) scroller.scrollTop = rowBottom - visibleRowHeight;
+      if (columns[columnIndex].fixed === void 0 && metric.left < scroller.scrollLeft + fixedWidth) scroller.scrollLeft = Math.max(0, metric.left - fixedWidth);
+      if (columns[columnIndex].fixed === void 0 && metric.left + cellWidth > scroller.scrollLeft + viewport.width - rightFixedWidth) scroller.scrollLeft = metric.left + cellWidth - viewport.width + rightFixedWidth;
+    }
+  }, [beginEdit, bodyTop, columns, editing, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, getRowKey, metrics, resolvedHeight, rightFixedWidth, rowHeight, rows, selection, setSelection, viewport.width]);
+  const editorStyle = useMemo(() => {
+    if (!editing) return void 0;
+    const metric = metrics[editing.columnIndex];
+    const fixedSide = columns[editing.columnIndex].fixed;
+    const span = getCellSpan(editing.rowIndex, editing.columnIndex);
+    const cellWidth = getCellDisplayWidth(editing.columnIndex, span?.colSpan ?? 1);
+    const cellHeight = rowHeight * (span?.rowSpan ?? 1);
+    const cellLeft = fixedSide === "left" ? metric.left : fixedSide === "right" ? viewport.width - (rightFixedOffsets.get(editing.columnIndex) ?? 0) - metric.width : metric.left - scrollRef.current.left;
+    return {
+      left: (fixedSide ? cellLeft : Math.max(cellLeft, fixedWidth)) + 1,
+      top: Math.max(fixedHeader ? bodyTop : 0, bodyTop + editing.rowIndex * rowHeight - scrollRef.current.top) + 1,
+      width: cellWidth - 2,
+      height: cellHeight - 2
+    };
+  }, [bodyTop, columns, editing, fixedHeader, fixedWidth, getCellDisplayWidth, getCellSpan, metrics, rightFixedOffsets, rowHeight, viewport.width]);
+  const handleColumnPointerDown = useCallback2((event) => {
+    const rect = event.currentTarget.getBoundingClientRect();
+    const localY = event.clientY - rect.top;
+    const headerY = fixedHeader ? 0 : -scrollRef.current.top;
+    if (localY < headerY || localY >= headerY + headerHeight) return;
+    const resizeIndex = locateResizeHandle(event.clientX);
+    if (resizeIndex >= 0) {
+      event.preventDefault();
+      event.currentTarget.setPointerCapture(event.pointerId);
+      columnDragRef.current = { type: "resize", columnIndex: resizeIndex, startX: event.clientX, startWidth: metrics[resizeIndex].width };
+      suppressClickRef.current = true;
+      setDragGuide(getDisplayedColumnLeft(resizeIndex) + metrics[resizeIndex].width);
+      return;
+    }
+  }, [fixedHeader, getDisplayedColumnLeft, headerHeight, locateResizeHandle, metrics, setDragGuide]);
+  const handleColumnPointerMove = useCallback2((event) => {
+    const drag = columnDragRef.current;
+    if (!drag) return;
+    const width2 = Math.max(getMinimumColumnWidth(columns[drag.columnIndex], columnDraggable), Math.round(drag.startWidth + event.clientX - drag.startX));
+    onColumnResize?.(columns[drag.columnIndex].key, width2);
+    setDragGuide(getDisplayedColumnLeft(drag.columnIndex) + width2);
+  }, [columnDraggable, columns, getDisplayedColumnLeft, onColumnResize, setDragGuide]);
+  const handleColumnPointerUp = useCallback2((event) => {
+    const drag = columnDragRef.current;
+    if (!drag) return;
+    if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
+    columnDragRef.current = null;
+    setDragGuide(null);
+  }, [setDragGuide]);
+  const queueSortStateChange = useCallback2((next) => {
+    setDisplaySortState(next);
+    if (sortDebounceRef.current !== null) clearTimeout(sortDebounceRef.current);
+    sortDebounceRef.current = setTimeout(() => {
+      sortDebounceRef.current = null;
+      onSortStateChange?.(next);
+    }, 200);
+  }, [onSortStateChange]);
+  const renderHeaderIcons = (columnIndex, left) => {
+    const column = columns[columnIndex];
+    if (column.rowSelection || column.rowDragHandle || column.rowNumber) return null;
+    const top = (headerHeight - 14) / 2;
+    const visibleActions = getVisibleHeaderActions(column, metrics[columnIndex].width, columnDraggable, measureHeaderTitleWidth(columnIndex));
+    let right = left + metrics[columnIndex].width - (visibleActions.drag ? 18 : 4);
+    const icons = [];
+    if (visibleActions.drag) {
+      const hovered = hoveredHeaderAction?.columnIndex === columnIndex && hoveredHeaderAction.action === "drag";
+      icons.push(
+        /* @__PURE__ */ jsx7(HeaderDragIcon, { className: `rvg-header-icon rvg-header-drag-icon${hovered ? " is-hovered" : ""}`, style: { left: left + metrics[columnIndex].width - 16, top } }, "drag")
+      );
+    }
+    if (visibleActions.sort) {
+      const hovered = hoveredHeaderAction?.columnIndex === columnIndex && hoveredHeaderAction.action === "sort";
+      const direction = displaySortState?.columnKey === column.key ? displaySortState.direction : null;
+      icons.push(
+        /* @__PURE__ */ jsx7(HeaderSortIcon, { className: `rvg-header-icon${hovered ? " is-hovered" : ""}`, style: { left: right - 16, top }, direction }, "sort")
+      );
+      right -= 18;
+    }
+    if (visibleActions.filter) {
+      const hovered = hoveredHeaderAction?.columnIndex === columnIndex && hoveredHeaderAction.action === "filter";
+      icons.push(
+        /* @__PURE__ */ jsx7(HeaderSearchIcon, { className: `rvg-header-icon rvg-header-search-icon${hovered ? " is-hovered" : ""}${filterValues[column.key] ? " is-active" : ""}`, style: { left: right - 16, top: top + 1 } }, "filter")
+      );
+    }
+    return icons;
+  };
+  const headerTooltip = (() => {
+    if (!visibleHeaderTooltip) return null;
+    const { columnIndex, action } = visibleHeaderTooltip;
+    const column = columns[columnIndex];
+    if (!column) return null;
+    const columnRight = getDisplayedColumnLeft(columnIndex) + metrics[columnIndex].width;
+    const visibleActions = getVisibleHeaderActions(column, metrics[columnIndex].width, columnDraggable, measureHeaderTitleWidth(columnIndex));
+    let anchorX = columnRight - (visibleActions.drag ? 18 : 4);
+    let anchorLeft = anchorX;
+    let label;
+    if (action === "title") {
+      const titleWidth = measureHeaderTitleWidth(columnIndex);
+      const actionWidth = (Number(visibleActions.drag) + Number(visibleActions.filter) + Number(visibleActions.sort)) * 18;
+      const contentWidth2 = Math.max(0, metrics[columnIndex].width - actionWidth);
+      const textWidth = Math.min(titleWidth, Math.max(0, contentWidth2 - 20));
+      const columnLeft = getDisplayedColumnLeft(columnIndex);
+      anchorX = column.align === "right" ? columnLeft + contentWidth2 - 10 : column.align === "center" ? columnLeft + metrics[columnIndex].width / 2 + textWidth / 2 : columnLeft + 10 + textWidth;
+      anchorLeft = column.align === "right" ? anchorX - textWidth : column.align === "center" ? columnLeft + metrics[columnIndex].width / 2 - textWidth / 2 : columnLeft + 10;
+      label = column.title;
+    } else if (action === "drag") {
+      anchorX = columnRight;
+      anchorLeft = anchorX;
+      label = labels.dragColumn;
+    } else if (action === "sort") {
+      const direction = displaySortState?.columnKey === column.key ? displaySortState.direction : null;
+      label = direction === "asc" ? labels.sortAsc : direction === "desc" ? labels.sortDesc : labels.sortBoth;
+    } else {
+      if (visibleActions.sort) anchorX -= 18;
+      const value = filterValues[column.key];
+      label = value ? labels.filterWithValue(value) : labels.filter;
+    }
+    const placement = anchorX + 328 > viewport.width ? "left" : "right";
+    return {
+      left: placement === "right" ? anchorX + 8 : Math.max(8, anchorLeft - 8),
+      top: (fixedHeader ? 0 : -scrollPosition.top) + headerHeight / 2,
+      label,
+      placement
+    };
+  })();
+  const getRangeBounds = () => selectionRange ? {
+    rowStart: Math.min(selectionRange.anchor.rowIndex, selectionRange.focus.rowIndex),
+    rowEnd: Math.max(selectionRange.anchor.rowIndex, selectionRange.focus.rowIndex),
+    columnStart: Math.min(selectionRange.anchor.columnIndex, selectionRange.focus.columnIndex),
+    columnEnd: Math.max(selectionRange.anchor.columnIndex, selectionRange.focus.columnIndex)
+  } : null;
+  const getRangeCells = () => {
+    const bounds = getRangeBounds();
+    if (!bounds) return [];
+    const cells = [];
+    for (let rowIndex = bounds.rowStart; rowIndex <= bounds.rowEnd; rowIndex += 1) {
+      for (let columnIndex = bounds.columnStart; columnIndex <= bounds.columnEnd; columnIndex += 1) {
+        const column = columns[columnIndex];
+        if (column.rowSelection || column.rowDragHandle || column.rowNumber) continue;
+        cells.push({ rowIndex, columnIndex, rowKey: getRowKey(rows[rowIndex], rowIndex), columnKey: column.key });
+      }
+    }
+    return cells;
+  };
+  const getRangeText = () => {
+    const bounds = getRangeBounds();
+    if (!bounds) return "";
+    const columnIndices = columns.map((column, index) => ({ column, index })).slice(bounds.columnStart, bounds.columnEnd + 1).filter(({ column }) => !column.rowSelection && !column.rowDragHandle && !column.rowNumber).map(({ index }) => index);
+    return rows.slice(bounds.rowStart, bounds.rowEnd + 1).map((_, rowOffset) => columnIndices.map((columnIndex) => getCellLabel(bounds.rowStart + rowOffset, columnIndex)).join("	")).join("\n");
+  };
+  const isCellInRange = (cell) => {
+    const bounds = getRangeBounds();
+    return Boolean(bounds && cell.rowIndex >= bounds.rowStart && cell.rowIndex <= bounds.rowEnd && cell.columnIndex >= bounds.columnStart && cell.columnIndex <= bounds.columnEnd);
+  };
+  const handleCopy = (event) => {
+    const nativeSelection = window.getSelection();
+    if (nativeSelection && !nativeSelection.isCollapsed && nativeSelection.toString()) return;
+    if (selectionRange) {
+      event.clipboardData.setData("text/plain", getRangeText());
+      event.preventDefault();
+      return;
+    }
+    if (!selection) return;
+    const row = rows[selection.rowIndex];
+    const column = columns[selection.columnIndex];
+    if (!row || !column || getRowKey(row, selection.rowIndex) !== selection.rowKey || column.key !== selection.columnKey) return;
+    event.clipboardData.setData("text/plain", getCellLabel(selection.rowIndex, selection.columnIndex));
+    event.preventDefault();
+  };
+  const selectionIsCollapsed = () => {
+    const nativeSelection = window.getSelection();
+    return !nativeSelection || nativeSelection.isCollapsed;
+  };
+  const showToast = (type, message) => {
+    if (toastTimerRef.current !== null) clearTimeout(toastTimerRef.current);
+    setToast({ type, message });
+    toastTimerRef.current = setTimeout(() => {
+      toastTimerRef.current = null;
+      setToast(null);
+    }, 1800);
+  };
+  const showHeaderTooltipAfterDelay = (next) => {
+    const nextKey = next ? `${next.columnIndex}:${next.action}` : "";
+    if (nextKey && pendingHeaderTooltipKeyRef.current === nextKey) return;
+    pendingHeaderTooltipKeyRef.current = nextKey;
+    if (headerTooltipTimerRef.current !== null) clearTimeout(headerTooltipTimerRef.current);
+    if (!next) {
+      setVisibleHeaderTooltip(null);
+      return;
+    }
+    setVisibleHeaderTooltip(null);
+    headerTooltipTimerRef.current = setTimeout(() => {
+      headerTooltipTimerRef.current = null;
+      setVisibleHeaderTooltip(next);
+    }, TOOLTIP_DELAY);
+  };
+  const showCellTooltip = (next) => {
+    const nextKey = next ? `${next.rowIndex}:${next.columnIndex}:${next.label}:${next.color ?? ""}:${Number(next.annotation)}` : "";
+    if (nextKey && pendingCellTooltipKeyRef.current === nextKey) return;
+    pendingCellTooltipKeyRef.current = nextKey;
+    if (cellTooltipTimerRef.current !== null) clearTimeout(cellTooltipTimerRef.current);
+    setHoveredCellTooltip(next);
+  };
+  const showCellTooltipAfterDelay = (next) => {
+    const nextKey = next ? `${next.rowIndex}:${next.columnIndex}:${next.label}:${next.color ?? ""}:${Number(next.annotation)}` : "";
+    if (nextKey && pendingCellTooltipKeyRef.current === nextKey) return;
+    pendingCellTooltipKeyRef.current = nextKey;
+    if (cellTooltipTimerRef.current !== null) clearTimeout(cellTooltipTimerRef.current);
+    if (!next) {
+      setHoveredCellTooltip(null);
+      return;
+    }
+    setHoveredCellTooltip(null);
+    cellTooltipTimerRef.current = setTimeout(() => {
+      cellTooltipTimerRef.current = null;
+      setHoveredCellTooltip(next);
+    }, TOOLTIP_DELAY);
+  };
+  const openCellContextMenu = (cell, clientX, clientY) => {
+    const root = canvasRef.current?.getBoundingClientRect();
+    if (!root) return;
+    setInsertCounts({ before: 1, after: 1 });
+    setAnnotationOpen(false);
+    setSelection(cell);
+    setContextMenu({
+      type: "cell",
+      ...cell,
+      left: Math.min(Math.max(0, clientX - root.left), Math.max(0, viewport.width - 190)),
+      top: Math.min(Math.max(0, clientY - root.top), Math.max(0, resolvedHeight - 350))
+    });
+    onCellContextMenu?.({ ...cell, row: rows[cell.rowIndex], clientX, clientY });
+  };
+  const openHeaderContextMenu = (columnIndex, clientX, clientY) => {
+    const root = canvasRef.current?.getBoundingClientRect();
+    if (!root || columnIndex < 0) return;
+    setContextMenu({
+      type: "header",
+      columnIndex,
+      left: Math.min(Math.max(0, clientX - root.left), Math.max(0, viewport.width - 180)),
+      top: Math.min(Math.max(0, clientY - root.top), Math.max(0, resolvedHeight - 68))
+    });
+  };
+  const getRowDragOffset = (rowIndex) => {
+    if (!rowDragPreview || rowIndex === rowDragPreview.sourceIndex) return 0;
+    if (rowDragPreview.sourceIndex < rowDragPreview.targetIndex) {
+      return rowIndex > rowDragPreview.sourceIndex && rowIndex <= rowDragPreview.targetIndex ? -rowHeight : 0;
+    }
+    return rowIndex >= rowDragPreview.targetIndex && rowIndex < rowDragPreview.sourceIndex ? rowHeight : 0;
+  };
+  const renderAnnotationControls = (targetCells) => {
+    const getKey = (cell) => `${typeof cell.rowKey}:${String(cell.rowKey)}\0${cell.columnKey}`;
+    const hasAnnotation = targetCells.some((cell) => cellAnnotations.has(getKey(cell)));
+    const openAnnotation = (event) => {
+      if (!annotationOpen) {
+        const existing = targetCells.map((cell) => cellAnnotations.get(getKey(cell))).find(Boolean);
+        setAnnotationType(existing?.type ?? "corner");
+        setAnnotationColor(existing?.color ?? ANNOTATION_COLORS[0]);
+        setAnnotationContent(existing?.content ?? "");
+      }
+      const rect = event.currentTarget.getBoundingClientRect();
+      const viewportWidth = window.visualViewport?.width ?? window.innerWidth;
+      const viewportHeight = window.visualViewport?.height ?? window.innerHeight;
+      const horizontal = rect.right + 216 > viewportWidth - 8 ? "left" : "right";
+      const vertical = rect.top + 280 > viewportHeight - 8 ? "up" : "down";
+      setAnnotationPlacement(`${horizontal}-${vertical}`);
+      setAnnotationOpen(true);
+    };
+    const saveAnnotation = () => {
+      setCellAnnotations((current) => {
+        const next = new Map(current);
+        targetCells.forEach((cell) => next.set(getKey(cell), { type: annotationType, color: annotationColor, content: annotationContent }));
+        return next;
+      });
+      setAnnotationOpen(false);
+      setContextMenu(null);
+    };
+    return /* @__PURE__ */ jsxs7(Fragment3, { children: [
+      /* @__PURE__ */ jsxs7("div", { className: `rvg-annotation-submenu is-${annotationPlacement}`, onMouseEnter: openAnnotation, onMouseLeave: () => setAnnotationOpen(false), children: [
+        /* @__PURE__ */ jsxs7("button", { type: "button", role: "menuitem", className: "rvg-context-annotation-trigger", "aria-expanded": annotationOpen, children: [
+          /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-icon", children: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "annotation" }) }),
+          /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-label", children: labels.annotation }),
+          /* @__PURE__ */ jsx7(SubmenuArrowIcon, {})
+        ] }),
+        annotationOpen && /* @__PURE__ */ jsxs7("div", { className: `rvg-annotation-panel is-${annotationPlacement}`, role: "menu", children: [
+          /* @__PURE__ */ jsxs7("div", { className: `rvg-annotation-types${annotationType === "corner" ? " is-corner" : ""}`, role: "group", "aria-label": labels.annotationMode, children: [
+            /* @__PURE__ */ jsx7("button", { type: "button", className: annotationType === "background" ? "is-active" : "", onClick: () => setAnnotationType("background"), children: labels.annotationBackground }),
+            /* @__PURE__ */ jsx7("button", { type: "button", className: annotationType === "corner" ? "is-active" : "", onClick: () => setAnnotationType("corner"), children: labels.annotationCorner })
+          ] }),
+          /* @__PURE__ */ jsx7("div", { className: "rvg-annotation-colors", children: ANNOTATION_COLORS.map((color, index) => /* @__PURE__ */ jsx7("button", { type: "button", className: annotationColor === color ? "is-active" : "", "aria-label": labels.annotationColor(index + 1), title: labels.annotationColor(index + 1), style: { backgroundColor: color, "--annotation-color": color }, onClick: () => setAnnotationColor(color) }, color)) }),
+          /* @__PURE__ */ jsx7(
+            "textarea",
+            {
+              className: "rvg-annotation-content",
+              "aria-label": labels.annotationContent,
+              placeholder: labels.annotationPlaceholder,
+              rows: 3,
+              maxLength: 100,
+              value: annotationContent,
+              onChange: (event) => setAnnotationContent(event.target.value)
+            }
+          ),
+          /* @__PURE__ */ jsxs7("div", { className: "rvg-annotation-actions", children: [
+            /* @__PURE__ */ jsxs7("span", { children: [
+              annotationContent.length,
+              "/100"
+            ] }),
+            /* @__PURE__ */ jsx7("button", { type: "button", onClick: saveAnnotation, children: labels.confirm })
+          ] })
+        ] })
+      ] }),
+      hasAnnotation && /* @__PURE__ */ jsxs7("button", { type: "button", role: "menuitem", onClick: () => {
+        setCellAnnotations((current) => {
+          const next = new Map(current);
+          targetCells.forEach((cell) => next.delete(getKey(cell)));
+          return next;
+        });
+        setContextMenu(null);
+      }, children: [
+        /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-icon", children: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "remove-annotation" }) }),
+        /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-label", children: labels.removeAnnotation })
+      ] })
+    ] });
+  };
+  const createEmptyRows = (count) => {
+    return Array.from({ length: count }, () => {
+      const record = { id: createPendingInsertId() };
+      if (typeof rowKey === "string") record[rowKey] = record.id;
+      columns.forEach((column) => {
+        if (column.dataIndex !== void 0) record[String(column.dataIndex)] = "";
+      });
+      return record;
+    });
+  };
+  const insertRowsOptimistically = async (cell, position, count) => {
+    const row = rows[cell.rowIndex];
+    if (!row || !onInsertRows) return;
+    const sourceRowIndex = getSourceRowIndexByKey(cell.rowKey, cell.rowIndex);
+    const insertIndex = (sourceRowIndex >= 0 ? sourceRowIndex : cell.rowIndex) + (position === "after" ? 1 : 0);
+    const insertedRows = createEmptyRows(count);
+    const pending = {
+      id: createPendingInsertId(),
+      index: insertIndex,
+      rows: insertedRows,
+      keys: insertedRows.map((insertedRow, offset) => getDataRowKey(insertedRow, insertIndex + offset))
+    };
+    setContextMenu(null);
+    setInsertBusy(true);
+    setInsertedRowKeys((current) => {
+      const next = new Set(current);
+      pending.keys.forEach((key) => next.add(key));
+      return next;
+    });
+    setPendingInserts((current) => [...current, pending]);
+    try {
+      await Promise.resolve(onInsertRows({ rowIndex: sourceRowIndex >= 0 ? sourceRowIndex : cell.rowIndex, row, position, count, insertedRows }));
+      await waitForPaint();
+      setInsertBusy(false);
+    } catch (error) {
+      setPendingInserts((current) => current.filter((insert) => insert.id !== pending.id));
+      setInsertedRowKeys((current) => {
+        const next = new Set(current);
+        pending.keys.forEach((key) => next.delete(key));
+        return next;
+      });
+      setInsertBusy(false);
+      throw error;
+    }
+  };
+  const renderCellText = (rowIndex, columnIndex, left) => {
+    const column = columns[columnIndex];
+    const span = getCellSpan(rowIndex, columnIndex);
+    if (span && (span.rowIndex !== rowIndex || span.columnIndex !== columnIndex)) return null;
+    const colSpan = span?.colSpan ?? 1;
+    const rowSpan = span?.rowSpan ?? 1;
+    const cellWidth = getCellDisplayWidth(columnIndex, colSpan);
+    const cellHeight = rowHeight * rowSpan;
+    const dragOffset = getRowDragOffset(rowIndex);
+    const isDraggedSource = rowDragPreview?.sourceIndex === rowIndex;
+    const currentScrollTop = scrollRef.current.top;
+    const top = (fixedHeader ? 0 : bodyTop) + rowIndex * rowHeight - currentScrollTop;
+    if (column.rowSelection) {
+      const rowKey2 = getRowKey(rows[rowIndex], rowIndex);
+      return /* @__PURE__ */ jsx7(
+        "div",
+        {
+          className: "rvg-row-selection-icon",
+          style: { left, top, width: cellWidth, height: cellHeight, opacity: isDraggedSource ? 0 : 1, transform: `translateY(${dragOffset}px)` },
+          children: /* @__PURE__ */ jsx7(SelectionIcon, { checked: selectedRowKeySet.has(rowKey2), radio: rowSelectionMode === "single" })
+        },
+        `selection:${String(rowKey2)}`
+      );
+    }
+    if (column.rowDragHandle) {
+      return /* @__PURE__ */ jsx7(
+        "div",
+        {
+          className: "rvg-row-drag-icon",
+          style: { left, top, width: cellWidth, height: cellHeight, opacity: isDraggedSource ? 0 : 1, transform: `translateY(${dragOffset}px)` },
+          "aria-hidden": "true",
+          children: /* @__PURE__ */ jsx7(RowDragHandleIcon, {})
+        },
+        `drag:${String(getRowKey(rows[rowIndex], rowIndex))}`
+      );
+    }
+    if (column.renderCell && !(editing?.rowIndex === rowIndex && editing.columnIndex === columnIndex)) {
+      const row = rows[rowIndex];
+      const value = column.dataIndex === void 0 ? void 0 : row[column.dataIndex];
+      return /* @__PURE__ */ jsx7(
+        "div",
+        {
+          className: "rvg-cell-render",
+          style: {
+            left,
+            top,
+            width: cellWidth,
+            height: cellHeight,
+            justifyContent: column.align === "right" ? "flex-end" : column.align === "center" ? "center" : "flex-start",
+            opacity: isDraggedSource ? 0 : 1,
+            transform: `translateY(${dragOffset}px)`
+          },
+          children: column.renderCell(value, row, rowIndex)
+        },
+        `render:${String(getRowKey(row, rowIndex))}:${column.key}`
+      );
+    }
+    return null;
+  };
+  const renderHeaderTitle = (columnIndex, left) => {
+    const column = columns[columnIndex];
+    const currentScrollTop = scrollRef.current.top;
+    if (column.rowNumber) {
+      return /* @__PURE__ */ jsx7(
+        "div",
+        {
+          className: "rvg-header-title",
+          style: { left, top: fixedHeader ? 0 : -currentScrollTop, width: metrics[columnIndex].width, height: headerHeight, justifyContent: "center", padding: 0, textAlign: "center" },
+          children: /* @__PURE__ */ jsx7("span", { children: column.title })
+        },
+        column.key
+      );
+    }
+    if (column.rowSelection) {
+      if (rowSelectionMode === "single") return null;
+      const allSelected = rows.length > 0 && selectedRowKeySet.size === rows.length;
+      const indeterminate = selectedRowKeySet.size > 0 && !allSelected;
+      return /* @__PURE__ */ jsx7(
+        "div",
+        {
+          className: "rvg-header-selection-icon",
+          style: { left, top: fixedHeader ? 0 : -currentScrollTop, width: metrics[columnIndex].width, height: headerHeight },
+          children: /* @__PURE__ */ jsx7(SelectionIcon, { checked: allSelected, indeterminate })
+        },
+        column.key
+      );
+    }
+    return null;
+  };
+  const rangeHandlePosition = (() => {
+    if (!rangeSelection) return null;
+    const bounds = getRangeBounds();
+    if (!bounds) return null;
+    const metric = metrics[bounds.columnEnd];
+    if (!metric) return null;
+    const rawLeft = getDisplayedColumnLeft(bounds.columnEnd) + metric.width;
+    const rawTop = bodyTop + (bounds.rowEnd + 1) * rowHeight - scrollPosition.top;
+    const column = columns[bounds.columnEnd];
+    const horizontalStart = column.fixed === void 0 ? fixedWidth : 0;
+    const horizontalEnd = column.fixed === void 0 ? viewport.width - rightFixedWidth : viewport.width;
+    const verticalStart = fixedHeader ? bodyTop : 0;
+    if (rawLeft <= horizontalStart || rawLeft > horizontalEnd || rawTop <= verticalStart || rawTop > resolvedHeight) return null;
+    return { left: rawLeft, top: rawTop, bounds };
+  })();
+  const selectionOutlineStyle = (() => {
+    if (!selection || selectionRange) return null;
+    const row = rows[selection.rowIndex];
+    const metric = metrics[selection.columnIndex];
+    const column = columns[selection.columnIndex];
+    if (!row || !metric || !column || getRowKey(row, selection.rowIndex) !== selection.rowKey) return null;
+    const span = getCellSpan(selection.rowIndex, selection.columnIndex);
+    const rawLeft = getDisplayedColumnLeft(selection.columnIndex);
+    const rawRight = rawLeft + getCellDisplayWidth(selection.columnIndex, span?.colSpan ?? 1);
+    const rawTop = bodyTop + selection.rowIndex * rowHeight - scrollPosition.top;
+    const rawBottom = rawTop + rowHeight * (span?.rowSpan ?? 1);
+    const horizontalStart = column.fixed === void 0 ? fixedWidth : 0;
+    const horizontalEnd = column.fixed === void 0 ? viewport.width - rightFixedWidth : viewport.width;
+    const verticalStart = fixedHeader ? bodyTop : 0;
+    if (rawRight <= horizontalStart || rawLeft >= horizontalEnd || rawBottom <= verticalStart || rawTop >= resolvedHeight) return null;
+    const borderWidth = 2;
+    const left = Math.round(Math.max(rawLeft - borderWidth, horizontalStart - 1));
+    const right = Math.round(Math.min(rawRight + 1, horizontalEnd, viewport.width));
+    const top = Math.round(Math.max(rawTop - borderWidth, verticalStart - 1));
+    const bottom = Math.round(Math.min(rawBottom + 1, resolvedHeight));
+    return {
+      left,
+      top,
+      width: Math.max(0, right - left),
+      height: Math.max(0, bottom - top)
+    };
+  })();
+  const handleContextMenu = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    if (!contextMenuEnabled) return;
+    const rect = event.currentTarget.getBoundingClientRect();
+    const localY = event.clientY - rect.top;
+    const headerY = fixedHeader ? 0 : -scrollRef.current.top;
+    if (localY >= headerY && localY < headerY + headerHeight) {
+      const columnIndex = locateColumn(event.clientX);
+      if (columnIndex < 0) return;
+      if (columns[columnIndex].rowSelection || columns[columnIndex].rowDragHandle || columns[columnIndex].rowNumber) return;
+      openHeaderContextMenu(columnIndex, event.clientX, event.clientY);
+      return;
+    }
+    const cell = locateCell(event.clientX, event.clientY);
+    if (!cell) return;
+    if (columns[cell.columnIndex].rowSelection || columns[cell.columnIndex].rowDragHandle || columns[cell.columnIndex].rowNumber) return;
+    openCellContextMenu(cell, event.clientX, event.clientY);
+  };
+  const getMenuState = (item, context) => ({
+    hidden: typeof item?.hidden === "function" ? item.hidden(context) : item?.hidden,
+    disabled: typeof item?.disabled === "function" ? item.disabled(context) : item?.disabled
+  });
+  const renderContextMenuButton = (key, context, label, onClick, override, options) => {
+    const state = getMenuState(override, context);
+    if (state.hidden) return null;
+    const disabled = state.disabled ?? options?.disabled;
+    const danger = override?.danger ?? options?.danger;
+    const icon = override?.icon ?? options?.icon;
+    if (override?.render !== void 0 || override?.childrens !== void 0) {
+      return renderContextMenuSubmenu(key, context, override?.label ?? label, override, icon, disabled, danger);
+    }
+    return /* @__PURE__ */ jsxs7(
+      "button",
+      {
+        type: "button",
+        role: "menuitem",
+        className: danger ? "rvg-context-danger" : void 0,
+        disabled,
+        onClick: () => {
+          if (disabled) return;
+          if (override?.onClick) override.onClick(context);
+          else onClick();
+          setContextMenu(null);
+        },
+        children: [
+          icon && /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-icon", children: icon }),
+          /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-label", children: override?.label ?? label }),
+          override?.shortcut && /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-shortcut", children: override.shortcut })
+        ]
+      },
+      key
+    );
+  };
+  const renderCustomContextMenuItem = (item, context) => {
+    if (!item.label || !item.onClick && item.childrens === void 0 && item.render === void 0) return null;
+    return renderContextMenuButton(item.key, context, item.label, () => item.onClick?.(context), item);
+  };
+  const renderContextMenuSubmenu = (key, context, label, item, icon, disabled, danger) => {
+    let separatorPending = false;
+    const content = item.render !== void 0 ? typeof item.render === "function" ? item.render(context) : item.render : item.childrens?.map((child, index) => {
+      if (child === "|") {
+        separatorPending = true;
+        return null;
+      }
+      const node = renderCustomContextMenuItem(child, context);
+      if (!node) return null;
+      const wrapped = /* @__PURE__ */ jsxs7(Fragment2, { children: [
+        separatorPending && /* @__PURE__ */ jsx7("div", { className: "rvg-context-separator" }),
+        node
+      ] }, child.key);
+      separatorPending = false;
+      return wrapped;
+    });
+    return /* @__PURE__ */ jsxs7("div", { className: "rvg-context-submenu", children: [
+      /* @__PURE__ */ jsxs7("button", { type: "button", role: "menuitem", className: danger ? "rvg-context-danger" : void 0, disabled, "aria-haspopup": "menu", children: [
+        icon && /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-icon", children: icon }),
+        /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-label", children: label }),
+        /* @__PURE__ */ jsx7(SubmenuArrowIcon, {})
+      ] }),
+      /* @__PURE__ */ jsx7("div", { className: "rvg-context-submenu-panel", role: "menu", children: content })
+    ] }, key);
+  };
+  const renderConfiguredContextMenu = (items, context, renderBuiltin) => {
+    const nodes = [];
+    let separatorPending = false;
+    items.forEach((item, index) => {
+      if (item === "|") {
+        if (nodes.length > 0) separatorPending = true;
+        return;
+      }
+      const override = typeof item === "string" ? void 0 : item;
+      const key = typeof item === "string" ? item : item.key;
+      if (override && getMenuState(override, context).hidden) return;
+      const node = renderBuiltin(key, override) ?? (override ? renderCustomContextMenuItem(override, context) : null);
+      if (!node) return;
+      if (separatorPending) {
+        nodes.push(/* @__PURE__ */ jsx7("div", { className: "rvg-context-separator" }, `separator:${index}`));
+        separatorPending = false;
+      }
+      nodes.push(/* @__PURE__ */ jsx7(Fragment2, { children: node }, typeof item === "string" ? `${item}:${index}` : item.key));
+    });
+    return nodes;
+  };
+  const renderSummaryCell = (columnIndex, left) => {
+    const column = columns[columnIndex];
+    const isUtility = column.rowSelection || column.rowDragHandle || column.rowNumber;
+    const summaryContent = summaryValues.has(column.key) ? summaryValues.get(column.key) : summaryEmptyValue;
+    const content = column.rowNumber ? language === "zh-CN" ? "\u5408\u8BA1" : "Total" : summaryPending ? /* @__PURE__ */ jsx7("span", { className: "rvg-summary-skeleton" }) : summaryContent;
+    return /* @__PURE__ */ jsx7(
+      "div",
+      {
+        className: `rvg-summary-cell${isUtility ? " is-utility" : ""}${column.summary ? " is-summary" : ""}${summaryVerticalBordered ? "" : " is-borderless"}`,
+        style: {
+          left,
+          width: metrics[columnIndex].width,
+          justifyContent: column.align === "right" ? "flex-end" : column.align === "center" || isUtility ? "center" : "flex-start"
+        },
+        children: content
+      },
+      `summary:${column.key}`
+    );
+  };
+  const rootStyle = {
+    width,
+    height,
+    minHeight: typeof height === "number" ? void 0 : FALLBACK_HEIGHT,
+    ...stripedColor ? { "--rvg-color-stripe": stripedColor } : null,
+    ...style
+  };
+  const currentScroll = scrollRef.current;
+  const scrollerBottom = Math.max(0, bottomSummaryHeight - horizontalScrollbarHeight);
+  return /* @__PURE__ */ jsxs7("div", { className: `rvg-root${!hasVerticalBorders ? " is-vertical-borderless" : ""}${hasStripedRows ? " is-striped" : ""}${insertBusy ? " is-inserting" : ""}${deleteBusy ? " is-deleting" : ""} ${loading && !hasCompletedLoadRef.current && !hasCustomLoading ? "is-initial-loading" : ""} ${className}`, style: rootStyle, children: [
+    /* @__PURE__ */ jsxs7("div", { ref: scrollerRef, className: `rvg-scroller${contextMenu ? " is-context-menu-open" : ""}`, style: { bottom: scrollerBottom }, onScroll: handleScroll, onCopy: handleCopy, onContextMenu: handleContextMenu, tabIndex: 0, role: "grid", "aria-label": ariaLabel, "aria-rowcount": rows.length, "aria-colcount": columns.length, onKeyDown: handleKeyDown, children: [
+      /* @__PURE__ */ jsx7(
+        "canvas",
+        {
+          ref: canvasRef,
+          className: "rvg-canvas",
+          style: { width: viewport.width, height: resolvedHeight },
+          onMouseMove: (event) => {
+            if (columnDragRef.current) return;
+            const rect = event.currentTarget.getBoundingClientRect();
+            const localY = event.clientY - rect.top;
+            const headerY = fixedHeader ? 0 : -scrollRef.current.top;
+            const columnIndex = locateColumn(event.clientX);
+            const inHeader = localY >= headerY && localY < headerY + headerHeight;
+            const hoveredAction = inHeader ? locateHeaderAction(event.clientX, columnIndex) : null;
+            const hoveredDragHandle = inHeader && locateHeaderDragHandle(event.clientX, columnIndex);
+            const hoveredTitle = inHeader && !hoveredAction && !hoveredDragHandle && columnIndex >= 0 && Boolean(columns[columnIndex]?.title) && (tooltipConfig.header || isHeaderTitleTruncated(columnIndex));
+            const nextHover = hoveredAction ? { columnIndex, action: hoveredAction } : hoveredDragHandle ? { columnIndex, action: "drag" } : hoveredTitle ? { columnIndex, action: "title" } : null;
+            const previousHover = hoveredHeaderActionRef.current;
+            if (previousHover?.columnIndex !== nextHover?.columnIndex || previousHover?.action !== nextHover?.action) {
+              hoveredHeaderActionRef.current = nextHover;
+              setHoveredHeaderAction(nextHover);
+              showHeaderTooltipAfterDelay(nextHover);
+              scheduleDraw();
+            }
+            if (inHeader) {
+              if (hoveredRowIndexRef.current !== null) {
+                hoveredRowIndexRef.current = null;
+                scheduleDraw();
+              }
+              showCellTooltip(null);
+            } else {
+              showHeaderTooltipAfterDelay(null);
+              const cell = locateCell(event.clientX, event.clientY);
+              const nextHoveredRowIndex = cell?.rowIndex ?? null;
+              if (hoveredRowIndexRef.current !== nextHoveredRowIndex) {
+                hoveredRowIndexRef.current = nextHoveredRowIndex;
+                scheduleDraw();
+              }
+              if (!cell) {
+                showCellTooltipAfterDelay(null);
+              } else {
+                const annotation = cellAnnotations.get(`${typeof cell.rowKey}:${String(cell.rowKey)}\0${cell.columnKey}`);
+                if (annotation?.content.trim()) {
+                  const cellLeft = getDisplayedColumnLeft(cell.columnIndex);
+                  const cellTop = bodyTop + cell.rowIndex * rowHeight - scrollRef.current.top;
+                  const nextTooltip = { rowIndex: cell.rowIndex, columnIndex: cell.columnIndex, left: cellLeft + metrics[cell.columnIndex].width + 6, top: cellTop + rowHeight / 2, label: annotation.content, color: annotation.color, annotation: true };
+                  showCellTooltip(nextTooltip);
+                } else {
+                  const label = getCellLabel(cell.rowIndex, cell.columnIndex);
+                  const context = event.currentTarget.getContext("2d");
+                  if (context) context.font = "13px Inter, ui-sans-serif, system-ui, sans-serif";
+                  const truncated = Boolean(label && context && context.measureText(label).width + 20 > metrics[cell.columnIndex].width);
+                  if (!label || !tooltipConfig.cell && !truncated) {
+                    showCellTooltipAfterDelay(null);
+                  } else {
+                    const cellLeft = getDisplayedColumnLeft(cell.columnIndex);
+                    const cellTop = bodyTop + cell.rowIndex * rowHeight - scrollRef.current.top;
+                    const column = columns[cell.columnIndex];
+                    const labelWidth = context?.measureText(label).width ?? 0;
+                    const textWidth = Math.min(labelWidth, Math.max(0, metrics[cell.columnIndex].width - 20));
+                    const textRight = column.align === "right" ? cellLeft + metrics[cell.columnIndex].width - 10 : column.align === "center" ? cellLeft + metrics[cell.columnIndex].width / 2 + textWidth / 2 : cellLeft + 10 + textWidth;
+                    const textLeft = column.align === "right" ? textRight - textWidth : column.align === "center" ? cellLeft + metrics[cell.columnIndex].width / 2 - textWidth / 2 : cellLeft + 10;
+                    const localX = event.clientX - rect.left;
+                    const localY2 = event.clientY - rect.top;
+                    const textHeight = 22;
+                    const textTop = cellTop + (rowHeight - textHeight) / 2;
+                    const textBottom = textTop + textHeight;
+                    const hitPadding = column.renderCell ? 8 : 0;
+                    const isInsideText = localX >= textLeft - hitPadding && localX <= textRight + hitPadding && localY2 >= textTop && localY2 <= textBottom;
+                    if (!isInsideText) {
+                      showCellTooltipAfterDelay(null);
+                    } else {
+                      const placement = textRight + 330 > viewport.width ? "left" : "right";
+                      const nextTooltip = {
+                        rowIndex: cell.rowIndex,
+                        columnIndex: cell.columnIndex,
+                        left: placement === "right" ? textRight + 16 : Math.max(8, textLeft - 16),
+                        top: cellTop + rowHeight / 2,
+                        label,
+                        placement
+                      };
+                      showCellTooltipAfterDelay(nextTooltip);
+                    }
+                  }
+                }
+              }
+            }
+            const cursor = inHeader && locateResizeHandle(event.clientX) >= 0 ? "col-resize" : hoveredAction ? "pointer" : hoveredDragHandle ? "move" : columnIndex >= 0 && columns[columnIndex].rowSelection ? "pointer" : !inHeader && rowDraggable && columnIndex >= 0 && columns[columnIndex].rowDragHandle ? "move" : "default";
+            if (event.currentTarget.style.cursor !== cursor) event.currentTarget.style.cursor = cursor;
+          },
+          onMouseLeave: (event) => {
+            event.currentTarget.style.cursor = "default";
+            showCellTooltip(null);
+            showHeaderTooltipAfterDelay(null);
+            if (hoveredHeaderActionRef.current) {
+              hoveredHeaderActionRef.current = null;
+              setHoveredHeaderAction(null);
+              scheduleDraw();
+            }
+            if (hoveredRowIndexRef.current !== null) {
+              hoveredRowIndexRef.current = null;
+              scheduleDraw();
+            }
+          },
+          onPointerDown: (event) => {
+            handleColumnPointerDown(event);
+            beginRangeDrag(event);
+          },
+          onPointerMove: (event) => {
+            handleColumnPointerMove(event);
+            updateRangeDrag(event);
+          },
+          onPointerUp: (event) => {
+            handleColumnPointerUp(event);
+            endRangeDrag(event);
+          },
+          onPointerCancel: (event) => {
+            handleColumnPointerUp(event);
+            endRangeDrag(event);
+          },
+          onClick: (event) => {
+            if (suppressClickRef.current) {
+              suppressClickRef.current = false;
+              return;
+            }
+            const rect = event.currentTarget.getBoundingClientRect();
+            const localY = event.clientY - rect.top;
+            const headerY = fixedHeader ? 0 : -scrollRef.current.top;
+            if (localY >= headerY && localY < headerY + headerHeight) {
+              clickedCellRef.current = null;
+              const columnIndex = locateColumn(event.clientX);
+              const action = locateHeaderAction(event.clientX, columnIndex);
+              if (action === "sort") {
+                const columnKey = columns[columnIndex].key;
+                const next = displaySortState?.columnKey !== columnKey ? { columnKey, direction: "asc" } : displaySortState.direction === "asc" ? { columnKey, direction: "desc" } : null;
+                queueSortStateChange(next);
+                return;
+              }
+              if (action === "filter") {
+                const left = Math.min(Math.max(0, getDisplayedColumnLeft(columnIndex)), Math.max(0, viewport.width - 220));
+                setFilterEditor({ columnIndex, left, top: Math.max(0, headerY + headerHeight), draft: filterValues[columns[columnIndex].key] ?? "" });
+                return;
+              }
+              if (locateHeaderDragHandle(event.clientX, columnIndex)) return;
+              if (columnIndex >= 0 && columns[columnIndex].rowSelection && rowSelection) {
+                setRowKeys(rowKeys.length === rows.length ? [] : rows.map(getRowKey));
+              } else if (columnIndex >= 0 && (columns[columnIndex].rowDragHandle || columns[columnIndex].rowNumber)) {
+                return;
+              } else {
+                if (event.detail > 1) return;
+                selectColumn(columnIndex, event);
+              }
+              return;
+            }
+            const cell = locateCell(event.clientX, event.clientY);
+            if (!cell) return;
+            if (columns[cell.columnIndex].rowDragHandle || columns[cell.columnIndex].rowNumber) {
+              clickedCellRef.current = null;
+              return;
+            }
+            const clickedRowSelector = Boolean(columns[cell.columnIndex].rowSelection);
+            if (clickedRowSelector) {
+              clickedCellRef.current = null;
+              selectRow(cell.rowIndex, event, true);
+              return;
+            }
+            if (event.detail > 1) return;
+            clickedCellRef.current = cell;
+            setSelectionRange(null);
+            scrollerRef.current?.focus({ preventScroll: true });
+            setSelection(cell);
+            if (!hasRowSelectionColumn) {
+              selectRow(cell.rowIndex, event);
+            }
+            revealCell(cell);
+          },
+          onDoubleClick: (event) => {
+            const cell = clickedCellRef.current ?? locateCell(event.clientX, event.clientY);
+            if (cell) beginEdit(cell);
+          },
+          onContextMenu: handleContextMenu
+        }
+      ),
+      /* @__PURE__ */ jsxs7("div", { className: "rvg-text-layer", style: { width: viewport.width, height: resolvedHeight, marginTop: -resolvedHeight }, onContextMenu: handleContextMenu, children: [
+        /* @__PURE__ */ jsx7("div", { className: "rvg-text-scroll-clip", style: { left: fixedWidth, right: rightFixedWidth }, children: /* @__PURE__ */ jsxs7(
+          "div",
+          {
+            ref: scrollingTextRef,
+            className: "rvg-text-scroll-content",
+            style: { left: -fixedWidth, width: contentWidth, transform: `translateX(${-currentScroll.left}px)` },
+            children: [
+              columns.map((column, columnIndex) => column.fixed ? null : columnIndex >= domRange.columnStart && columnIndex < domRange.columnEnd ? /* @__PURE__ */ jsx7("span", { children: renderHeaderTitle(columnIndex, metrics[columnIndex].left) }, column.key) : null),
+              /* @__PURE__ */ jsx7("div", { className: "rvg-body-text-clip", style: { top: fixedHeader ? bodyTop : 0, bottom: 0 }, children: Array.from({ length: domRange.rowEnd - domRange.rowStart }, (_, offset) => domRange.rowStart + offset).flatMap((rowIndex) => columns.map((column, columnIndex) => {
+                if (column.fixed || columnIndex < domRange.columnStart || columnIndex >= domRange.columnEnd) return null;
+                return renderCellText(rowIndex, columnIndex, metrics[columnIndex].left);
+              })) })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsx7("div", { className: "rvg-body-text-clip", style: { top: fixedHeader ? bodyTop : 0, bottom: 0 }, children: Array.from({ length: domRange.rowEnd - domRange.rowStart }, (_, offset) => domRange.rowStart + offset).flatMap((rowIndex) => columns.map((column, columnIndex) => {
+          if (!column.fixed) return null;
+          const left = column.fixed === "left" ? metrics[columnIndex].left : viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width;
+          return renderCellText(rowIndex, columnIndex, left);
+        })) }),
+        columns.map((column, columnIndex) => column.fixed === "left" ? renderHeaderTitle(columnIndex, metrics[columnIndex].left) : null),
+        columns.map((column, columnIndex) => column.fixed === "right" ? renderHeaderTitle(columnIndex, viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width) : null)
+      ] }),
+      /* @__PURE__ */ jsx7("div", { className: "rvg-spacer", style: { width: contentWidth, height: contentHeight + bodyTop, marginTop: -resolvedHeight } })
+    ] }),
+    hasSummaryRow && /* @__PURE__ */ jsxs7(
+      "div",
+      {
+        className: `rvg-summary-row is-${summaryPosition}${hasVerticalBorders ? "" : " is-vertical-borderless"}`,
+        style: { height: rowHeight, top: summaryPosition === "top" ? headerHeight : void 0 },
+        children: [
+          /* @__PURE__ */ jsx7("div", { className: "rvg-summary-scroll-clip", style: { left: fixedWidth, right: rightFixedWidth }, children: /* @__PURE__ */ jsx7(
+            "div",
+            {
+              className: "rvg-summary-scroll-content",
+              style: { left: -fixedWidth, width: contentWidth, transform: `translateX(${-currentScroll.left}px)` },
+              children: columns.map((column, columnIndex) => column.fixed ? null : renderSummaryCell(columnIndex, metrics[columnIndex].left))
+            }
+          ) }),
+          /* @__PURE__ */ jsxs7("div", { className: "rvg-summary-fixed-layer", children: [
+            columns.map((column, columnIndex) => column.fixed === "left" ? renderSummaryCell(columnIndex, metrics[columnIndex].left) : null),
+            columns.map((column, columnIndex) => column.fixed === "right" ? renderSummaryCell(columnIndex, viewport.width - (rightFixedOffsets.get(columnIndex) ?? 0) - metrics[columnIndex].width) : null)
+          ] }),
+          fixedWidth > 0 && currentScroll.left > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-summary-fixed-shadow is-left", style: { left: fixedWidth } }),
+          rightFixedWidth > 0 && currentScroll.left < contentWidth - viewport.width && /* @__PURE__ */ jsx7("div", { className: "rvg-summary-fixed-shadow is-right", style: { right: rightFixedWidth } }),
+          summaryVerticalBordered && fixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-summary-fixed-border is-left", style: { left: fixedWidth - 1 } }),
+          summaryVerticalBordered && rightFixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-summary-fixed-border is-right", style: { right: rightFixedWidth } })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs7("div", { ref: headerIconsRef, className: "rvg-header-icons", style: { height: headerHeight, transform: `translateY(${fixedHeader ? 0 : -scrollRef.current.top}px)` }, children: [
+      /* @__PURE__ */ jsx7("div", { className: "rvg-header-scroll-clip", style: { left: fixedWidth, right: rightFixedWidth }, children: /* @__PURE__ */ jsx7(
+        "div",
+        {
+          ref: scrollingHeaderIconsRef,
+          className: "rvg-header-icon-layer rvg-header-icon-layer-scroll",
+          style: { left: -fixedWidth, width: contentWidth, transform: `translateX(${-scrollRef.current.left}px)` },
+          children: columns.map((column, index) => column.fixed ? null : /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, metrics[index].left) }, column.key))
+        }
+      ) }),
+      /* @__PURE__ */ jsxs7("div", { className: "rvg-header-icon-layer", children: [
+        columns.map((column, index) => column.fixed === "left" ? /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, metrics[index].left) }, column.key) : null),
+        columns.map((column, index) => column.fixed === "right" ? /* @__PURE__ */ jsx7("span", { children: renderHeaderIcons(index, viewport.width - (rightFixedOffsets.get(index) ?? 0) - metrics[index].width) }, column.key) : null)
+      ] })
+    ] }),
+    headerTooltip && /* @__PURE__ */ jsx7("div", { className: `rvg-header-tooltip is-${headerTooltip.placement}`, role: "tooltip", style: { left: headerTooltip.left, top: headerTooltip.top }, children: headerTooltip.label }),
+    hoveredCellTooltip && /* @__PURE__ */ jsx7(
+      "div",
+      {
+        className: `rvg-cell-tooltip${hoveredCellTooltip.annotation ? " is-annotation" : ` is-${hoveredCellTooltip.placement ?? "right"}`}`,
+        role: "tooltip",
+        style: {
+          left: hoveredCellTooltip.left,
+          top: hoveredCellTooltip.top,
+          ...hoveredCellTooltip.color ? {
+            backgroundColor: hoveredCellTooltip.color,
+            color: (() => {
+              const hex = hoveredCellTooltip.color.slice(1);
+              const red = Number.parseInt(hex.slice(0, 2), 16);
+              const green = Number.parseInt(hex.slice(2, 4), 16);
+              const blue = Number.parseInt(hex.slice(4, 6), 16);
+              return red * 0.299 + green * 0.587 + blue * 0.114 > 165 ? "#202124" : "#ffffff";
+            })()
+          } : {}
+        },
+        children: hoveredCellTooltip.label
+      }
+    ),
+    rangeHandlePosition && /* @__PURE__ */ jsx7(
+      "div",
+      {
+        className: "rvg-range-handle",
+        style: { left: rangeHandlePosition.left, top: rangeHandlePosition.top },
+        role: "presentation",
+        onPointerDown: (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+          const { rowStart, rowEnd, columnStart, columnEnd } = rangeHandlePosition.bounds;
+          const anchor = { rowIndex: rowStart, columnIndex: columnStart, rowKey: getRowKey(rows[rowStart], rowStart), columnKey: columns[columnStart].key };
+          const focus = { rowIndex: rowEnd, columnIndex: columnEnd, rowKey: getRowKey(rows[rowEnd], rowEnd), columnKey: columns[columnEnd].key };
+          rangeDragRef.current = { anchor, moved: true };
+          setSelectionRange({ anchor, focus });
+          event.currentTarget.setPointerCapture(event.pointerId);
+        },
+        onPointerMove: updateRangeDrag,
+        onPointerUp: endRangeDrag,
+        onPointerCancel: endRangeDrag,
+        onClick: () => {
+          suppressClickRef.current = false;
+        }
+      }
+    ),
+    selectionOutlineStyle && /* @__PURE__ */ jsx7("div", { ref: selectionFocusRef, className: "rvg-selection-focus", style: selectionOutlineStyle, "aria-hidden": "true" }),
+    contextMenu && /* @__PURE__ */ jsx7("div", { ref: contextMenuRef, className: "rvg-context-menu", role: "menu", style: { left: contextMenu.left, top: contextMenu.top }, children: contextMenu.type === "header" ? (() => {
+      const column = columns[contextMenu.columnIndex];
+      const headerContext = { column, columnIndex: contextMenu.columnIndex };
+      return renderConfiguredContextMenu(resolveContextMenuSection(customContextMenuConfig?.header, DEFAULT_HEADER_CONTEXT_MENU), headerContext, (item, override) => {
+        if (item === "copy") return renderContextMenuButton("header-copy", headerContext, labels.copyContent, async () => {
+          try {
+            await navigator.clipboard.writeText(rows.map((_, rowIndex) => getCellLabel(rowIndex, contextMenu.columnIndex)).join("\n"));
+            showToast("success", labels.copySuccess);
+          } catch {
+            showToast("error", labels.copyError);
+          }
+        }, override, { icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "copy" }) });
+        if (item === "select-column") {
+          if (!columnSelection) return null;
+          return renderContextMenuButton("header-select-column", headerContext, selectedColumnKeySet.has(column.key) ? labels.deselectColumn : labels.selectColumn, () => {
+            toggleColumnFromMenu(contextMenu.columnIndex);
+          }, override, { icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "select-column" }) });
+        }
+        return null;
+      });
+    })() : selectionRange && isCellInRange(contextMenu) ? (() => {
+      const rangeCells = getRangeCells();
+      const rangeContext = {
+        cells: rangeCells.map((cell) => {
+          const column = columns[cell.columnIndex];
+          const row = rows[cell.rowIndex];
+          return { ...cell, row, column, value: column.dataIndex === void 0 ? void 0 : row[column.dataIndex] };
+        })
+      };
+      return renderConfiguredContextMenu(resolveContextMenuSection(customContextMenuConfig?.range, DEFAULT_RANGE_CONTEXT_MENU), rangeContext, (item, override) => {
+        if (item === "copy") return renderContextMenuButton("range-copy", rangeContext, labels.copyContent, async () => {
+          try {
+            await navigator.clipboard.writeText(getRangeText());
+            showToast("success", labels.copySuccess);
+          } catch {
+            showToast("error", labels.copyError);
+          }
+        }, override, { icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "copy" }) });
+        if (item === "annotation") return renderAnnotationControls(rangeCells);
+        if (item === "undo") {
+          const changedCells = rangeCells.flatMap((cell) => {
+            const column = columns[cell.columnIndex];
+            const row = rows[cell.rowIndex];
+            if (column.dataIndex === void 0) return [];
+            const originalValue = originalCellValuesRef.current.get(getCellEditKey(cell));
+            if (originalValue === void 0) return [];
+            return [{ cell, row, column, originalValue }];
+          });
+          if (changedCells.length === 0) return null;
+          return renderContextMenuButton("range-undo", rangeContext, labels.undoChange, () => {
+            changedCells.forEach(({ cell, row, column, originalValue }) => {
+              if (column.dataIndex === void 0) return;
+              const editKey = getCellEditKey(cell);
+              const previousValue = row[column.dataIndex];
+              const value = typeof previousValue === "number" && originalValue !== "" ? Number(originalValue) : originalValue;
+              originalCellValuesRef.current.delete(editKey);
+              setEditedCellKeys((current) => {
+                if (!current.has(editKey)) return current;
+                const next = new Set(current);
+                next.delete(editKey);
+                return next;
+              });
+              onCellChange?.({ ...cell, row, previousValue, value });
+            });
+          }, override, { disabled: !onCellChange, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "undo" }) });
+        }
+        if (item === "clear") {
+          const hasClearableCell = rangeCells.some((cell) => {
+            const column = columns[cell.columnIndex];
+            const row = rows[cell.rowIndex];
+            return column.dataIndex !== void 0 && !isEmptyCellValue(row[column.dataIndex]);
+          });
+          if (!hasClearableCell) return null;
+          return renderContextMenuButton("range-clear", rangeContext, labels.clearContent, () => {
+            rangeCells.forEach((cell) => {
+              const column = columns[cell.columnIndex];
+              const row = rows[cell.rowIndex];
+              if (column.dataIndex === void 0 || isEmptyCellValue(row[column.dataIndex])) return;
+              markCellEdited(cell, row[column.dataIndex], "");
+              onCellChange?.({ ...cell, row, previousValue: row[column.dataIndex], value: "" });
+            });
+          }, override, { disabled: !onCellChange, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "clear" }) });
+        }
+        return null;
+      });
+    })() : (() => {
+      const cell = contextMenu;
+      const column = columns[cell.columnIndex];
+      const row = rows[cell.rowIndex];
+      const dataIndex = column.dataIndex;
+      const editKey = getCellEditKey(cell);
+      const originalValue = originalCellValuesRef.current.get(editKey);
+      const selectedIndices = rows.reduce((indices, item, index) => {
+        if (selectedRowKeySet.has(getRowKey(item, index))) indices.push(index);
+        return indices;
+      }, []);
+      const affectedRows = selectedIndices.includes(cell.rowIndex) ? selectedIndices : [cell.rowIndex];
+      const cellContext = { ...cell, row, column, value: dataIndex === void 0 ? void 0 : row[dataIndex] };
+      return renderConfiguredContextMenu(resolveContextMenuSection(customContextMenuConfig?.cell, DEFAULT_CELL_CONTEXT_MENU), cellContext, (item, override) => {
+        if (item === "edit") return renderContextMenuButton("cell-edit", cellContext, labels.edit, () => beginEdit(cell), override, { disabled: !column.editable, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "edit" }) });
+        if (item === "copy") return renderContextMenuButton("cell-copy", cellContext, labels.copyContent, async () => {
+          try {
+            await navigator.clipboard.writeText(getCellLabel(cell.rowIndex, cell.columnIndex));
+            showToast("success", labels.copySuccess);
+          } catch {
+            showToast("error", labels.copyError);
+          }
+        }, override, { icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "copy" }) });
+        if (item === "undo") return renderContextMenuButton("cell-undo", cellContext, labels.undoChange, () => {
+          if (dataIndex === void 0 || originalValue === void 0) return;
+          const previousValue = row[dataIndex];
+          const value = typeof previousValue === "number" && originalValue !== "" ? Number(originalValue) : originalValue;
+          setConfirmAction({ type: "undo", cell, row, dataIndex, previousValue, value });
+        }, override, { disabled: !onCellChange || dataIndex === void 0 || originalValue === void 0, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "undo" }) });
+        if (item === "clear") {
+          if (dataIndex === void 0 || isEmptyCellValue(row[dataIndex])) return null;
+          return renderContextMenuButton("cell-clear", cellContext, labels.clearContent, () => {
+            if (dataIndex === void 0) return;
+            const previousValue = row[dataIndex];
+            setConfirmAction({ type: "clear", cell, row, dataIndex, previousValue });
+          }, override, { disabled: !onCellChange || dataIndex === void 0, danger: true, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "clear" }) });
+        }
+        if (item === "annotation") return renderAnnotationControls([cell]);
+        if (item === "select-row") {
+          if (!rowSelection) return null;
+          return renderContextMenuButton("cell-select-row", cellContext, selectedRowKeySet.has(cell.rowKey) ? labels.deselectRow : labels.selectRow, () => {
+            if (selectedRowKeySet.has(cell.rowKey)) setRowKeys(rowKeys.filter((key) => key !== cell.rowKey));
+            else setRowKeys(rowSelectionMode === "single" ? [cell.rowKey] : [...rowKeys, cell.rowKey]);
+          }, override, { icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "select-row" }) });
+        }
+        if (item === "select-column") {
+          if (!columnSelection) return null;
+          return renderContextMenuButton("cell-select-column", cellContext, selectedColumnKeySet.has(cell.columnKey) ? labels.deselectColumn : labels.selectColumn, () => {
+            toggleColumnFromMenu(cell.columnIndex);
+          }, override, { icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "select-column" }) });
+        }
+        if (item === "insert-above") return /* @__PURE__ */ jsxs7("div", { className: "rvg-context-insert", children: [
+          /* @__PURE__ */ jsxs7("button", { type: "button", role: "menuitem", disabled: !onInsertRows, onClick: () => {
+            void insertRowsOptimistically(cell, "before", insertCounts.before);
+          }, children: [
+            /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-icon", children: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "insert-above" }) }),
+            /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-label", children: labels.insertAbove })
+          ] }),
+          /* @__PURE__ */ jsx7("input", { "aria-label": labels.insertAboveCount, type: "number", min: 1, max: 5, step: 1, value: insertCounts.before, onChange: (event) => setInsertCounts((current) => ({ ...current, before: Math.max(1, Math.min(5, Math.floor(Number(event.target.value) || 1))) })) }),
+          /* @__PURE__ */ jsx7("span", { children: labels.rowUnit })
+        ] });
+        if (item === "insert-below") return /* @__PURE__ */ jsxs7("div", { className: "rvg-context-insert", children: [
+          /* @__PURE__ */ jsxs7("button", { type: "button", role: "menuitem", disabled: !onInsertRows, onClick: () => {
+            void insertRowsOptimistically(cell, "after", insertCounts.after);
+          }, children: [
+            /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-icon", children: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "insert-below" }) }),
+            /* @__PURE__ */ jsx7("span", { className: "rvg-context-menu-label", children: labels.insertBelow })
+          ] }),
+          /* @__PURE__ */ jsx7("input", { "aria-label": labels.insertBelowCount, type: "number", min: 1, max: 5, step: 1, value: insertCounts.after, onChange: (event) => setInsertCounts((current) => ({ ...current, after: Math.max(1, Math.min(5, Math.floor(Number(event.target.value) || 1))) })) }),
+          /* @__PURE__ */ jsx7("span", { children: labels.rowUnit })
+        ] });
+        if (item === "move-up") {
+          if (!rowDraggable || !onRowOrderChange) return null;
+          return renderContextMenuButton("cell-move-up", cellContext, labels.moveUp, () => onRowOrderChange(cell.rowIndex, cell.rowIndex - 1), override, { disabled: cell.rowIndex === 0, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "move-up" }) });
+        }
+        if (item === "move-down") {
+          if (!rowDraggable || !onRowOrderChange) return null;
+          return renderContextMenuButton("cell-move-down", cellContext, labels.moveDown, () => onRowOrderChange(cell.rowIndex, cell.rowIndex + 1), override, { disabled: cell.rowIndex === rows.length - 1, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "move-down" }) });
+        }
+        if (item === "delete-row") return renderContextMenuButton("cell-delete-row", cellContext, labels.deleteRow, () => setConfirmAction({ type: "delete-row", rows: affectedRows.map((rowIndex) => ({ rowIndex, row: rows[rowIndex] })) }), override, { disabled: !onDeleteRows, danger: true, icon: /* @__PURE__ */ jsx7(ContextMenuIcon, { type: "delete" }) });
+        return null;
+      });
+    })() }),
+    confirmAction && /* @__PURE__ */ jsx7("div", { className: "rvg-confirm-backdrop", role: "presentation", onMouseDown: (event) => {
+      if (!confirmLoading && event.target === event.currentTarget) setConfirmAction(null);
+    }, children: /* @__PURE__ */ jsxs7("div", { className: "rvg-confirm", role: "alertdialog", "aria-modal": "true", "aria-labelledby": "rvg-delete-title", children: [
+      /* @__PURE__ */ jsx7("strong", { id: "rvg-delete-title", children: confirmAction.type === "undo" ? labels.undoConfirmTitle : confirmAction.type === "clear" ? labels.clearConfirmTitle : labels.deleteConfirmTitle }),
+      /* @__PURE__ */ jsx7("p", { children: confirmAction.type === "undo" ? labels.undoConfirmDescription : confirmAction.type === "clear" ? labels.clearConfirmDescription : labels.deleteConfirmDescription(confirmAction.rows.length) }),
+      /* @__PURE__ */ jsxs7("div", { className: "rvg-confirm-actions", children: [
+        /* @__PURE__ */ jsx7("button", { type: "button", disabled: confirmLoading, onClick: () => setConfirmAction(null), children: labels.cancel }),
+        /* @__PURE__ */ jsxs7("button", { type: "button", className: "rvg-confirm-danger", disabled: confirmLoading, autoFocus: true, onClick: () => {
+          if (confirmLoading) return;
+          flushSync(() => setConfirmLoading(true));
+          window.requestAnimationFrame(async () => {
+            try {
+              if (confirmAction.type === "undo") {
+                const editKey = getCellEditKey(confirmAction.cell);
+                setEditedCellKeys((current) => {
+                  if (!current.has(editKey)) return current;
+                  const next = new Set(current);
+                  next.delete(editKey);
+                  return next;
+                });
+                await Promise.resolve(onCellChange?.({ ...confirmAction.cell, row: confirmAction.row, previousValue: confirmAction.previousValue, value: confirmAction.value }));
+              } else if (confirmAction.type === "clear") {
+                markCellEdited(confirmAction.cell, confirmAction.previousValue, "");
+                await Promise.resolve(onCellChange?.({ ...confirmAction.cell, row: confirmAction.row, previousValue: confirmAction.previousValue, value: "" }));
+              } else {
+                const deletingKeys = confirmAction.rows.map(({ row, rowIndex }) => getDataRowKey(row, rowIndex));
+                setConfirmAction(null);
+                setConfirmLoading(false);
+                if (onDeleteRows) {
+                  setDeleteBusy(true);
+                  try {
+                    await Promise.resolve(onDeleteRows({ rows: confirmAction.rows, viewportRange: domRange }));
+                  } finally {
+                    setDeleteBusy(false);
+                  }
+                } else {
+                  setPendingDeletedRowKeys((current) => {
+                    const next = new Set(current);
+                    deletingKeys.forEach((key) => next.add(key));
+                    return next;
+                  });
+                }
+                return;
+              }
+              setConfirmAction(null);
+            } catch (error) {
+              setConfirmLoading(false);
+              throw error;
+            }
+          });
+        }, children: [
+          confirmLoading && /* @__PURE__ */ jsx7(LoadingSpinnerIcon, {}),
+          confirmAction.type === "undo" ? labels.undoChange : confirmAction.type === "clear" ? labels.clear : labels.delete
+        ] })
+      ] })
+    ] }) }),
+    toast && /* @__PURE__ */ jsx7("div", { className: `rvg-toast is-${toast.type}`, role: "status", children: toast.message }),
+    /* @__PURE__ */ jsx7("div", { ref: dragGuideRef, className: "rvg-column-guide" }),
+    /* @__PURE__ */ jsx7("div", { ref: rowDragGuideRef, className: "rvg-row-guide" }),
+    filterEditor && /* @__PURE__ */ jsxs7("div", { ref: filterRef, className: "rvg-filter", style: { left: filterEditor.left, top: filterEditor.top }, children: [
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          autoFocus: true,
+          "aria-label": labels.filterColumn(columns[filterEditor.columnIndex].title),
+          placeholder: labels.search,
+          value: filterEditor.draft,
+          onChange: (event) => {
+            const value = event.target.value;
+            setFilterEditor((current) => current ? { ...current, draft: value } : current);
+          },
+          onKeyDown: (event) => {
+            if (event.key === "Escape") setFilterEditor(null);
+            if (event.key === "Enter") {
+              const key = columns[filterEditor.columnIndex].key;
+              const next = { ...filterValues };
+              if (filterEditor.draft) next[key] = filterEditor.draft;
+              else delete next[key];
+              onFilterValuesChange?.(next);
+              setFilterEditor(null);
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs7("div", { className: "rvg-filter-actions", children: [
+        /* @__PURE__ */ jsx7("button", { type: "button", onClick: () => {
+          const key = columns[filterEditor.columnIndex].key;
+          const next = { ...filterValues };
+          delete next[key];
+          onFilterValuesChange?.(next);
+          setFilterEditor(null);
+        }, children: labels.reset }),
+        /* @__PURE__ */ jsx7("button", { type: "button", className: "rvg-filter-confirm", onClick: () => {
+          const key = columns[filterEditor.columnIndex].key;
+          const next = { ...filterValues };
+          if (filterEditor.draft) next[key] = filterEditor.draft;
+          else delete next[key];
+          onFilterValuesChange?.(next);
+          setFilterEditor(null);
+        }, children: labels.confirm })
+      ] })
+    ] }),
+    renderEditor(),
+    rows.length === 0 && !loading && /* @__PURE__ */ jsx7("div", { className: "rvg-empty", children: emptyContent ?? /* @__PURE__ */ jsx7(DefaultEmptyState, { label: labels.empty }) }),
+    loading && hasCustomLoading && /* @__PURE__ */ jsx7("div", { className: "rvg-custom-loading", "aria-label": labels.refreshing, children: loadingContent }),
+    loading && !hasCustomLoading && !hasCompletedLoadRef.current && /* @__PURE__ */ jsxs7("div", { className: "rvg-initial-loading", style: { top: headerHeight }, "aria-label": labels.initialLoading, children: [
+      Array.from({ length: Math.ceil((resolvedHeight - headerHeight) / rowHeight) }, (_, rowIndex) => /* @__PURE__ */ jsx7("div", { className: "rvg-loading-row", style: { height: rowHeight }, children: columns.map((column, columnIndex) => {
+        const left = getDisplayedColumnLeft(columnIndex);
+        const columnWidth = metrics[columnIndex].width;
+        if (left + columnWidth <= 0 || left >= viewport.width) return null;
+        const isUtility = column.rowSelection || column.rowDragHandle || column.rowNumber;
+        return /* @__PURE__ */ jsx7(
+          "span",
+          {
+            className: column.rowDragHandle ? "is-utility is-drag" : column.rowSelection ? "is-utility is-selection" : void 0,
+            style: { left, width: columnWidth, zIndex: column.fixed ? 1 : 0, background: column.fixed ? "#fff" : void 0, justifyContent: column.align === "right" ? "flex-end" : column.align === "center" || isUtility ? "center" : "flex-start" },
+            children: /* @__PURE__ */ jsx7("i", { style: { width: isUtility ? 14 : `${38 + (rowIndex * 17 + columnIndex * 13) % 43}%`, animationDelay: `${(rowIndex * columns.length + columnIndex) * 24}ms` } })
+          },
+          column.key
+        );
+      }) }, rowIndex)),
+      fixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-loading-fixed-shadow is-left", style: { left: fixedWidth } }),
+      rightFixedWidth > 0 && /* @__PURE__ */ jsx7("div", { className: "rvg-loading-fixed-shadow is-right", style: { right: rightFixedWidth } })
+    ] }),
+    loading && !hasCustomLoading && hasCompletedLoadRef.current && /* @__PURE__ */ jsx7("div", { className: "rvg-refresh-loading", "aria-label": labels.refreshing, children: /* @__PURE__ */ jsx7(LoadingSpinnerIcon, {}) })
+  ] });
+}
+export {
+  Table,
+  Table as VelocityGrid,
+  buildColumnMetrics,
+  getViewportRange,
+  hitTestColumn
+};