@pixerate/editor-react 0.16.0 → 0.18.0

package/dist/chunk-34HEZX7J.js

@@ -0,0 +1,2144 @@
+// src/spreadsheet/useSpreadsheetEditor.ts
+import { useState, useRef, useCallback, useMemo } from "react";
+import {
+  SpreadsheetController,
+  bindSpreadsheetTableActions
+} from "@pixerate/editor/spreadsheet";
+function useSpreadsheetEditor(options = {}) {
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const settersRef = useRef({});
+  const [controller] = useState(
+    () => new SpreadsheetController({
+      ...options,
+      onDocumentChange: (updated) => {
+        settersRef.current.setDoc?.({ ...updated });
+        optionsRef.current.onDocumentChange?.(updated);
+      },
+      onSelectionChange: (active, range) => {
+        settersRef.current.setActiveCell?.(active);
+        settersRef.current.setSelectedRange?.(range);
+        optionsRef.current.onSelectionChange?.(active, range);
+      },
+      onCellCommit: (rowId, colId, raw, value) => {
+        optionsRef.current.onCellCommit?.(rowId, colId, raw, value);
+      }
+    })
+  );
+  const [doc, setDoc] = useState(() => ({ ...controller.document }));
+  const [activeCell, setActiveCell] = useState(controller.activeCell);
+  const [selectedRange, setSelectedRange] = useState(controller.selectedRange);
+  const [editingCell, setEditingCell] = useState(null);
+  const [draftValue, setDraftState] = useState("");
+  const [validationPrompt, setValidationPrompt] = useState(null);
+  settersRef.current = { setDoc, setActiveCell, setSelectedRange };
+  const setDraftValue = useCallback((value) => {
+    controller.draftValue = value;
+    setDraftState(value);
+  }, [controller]);
+  const setCellValue = useCallback((rowId, colId, raw) => {
+    controller.setCellValue(rowId, colId, raw);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const selectCell = useCallback((row, col, extendSelection = false) => {
+    controller.selectCell(row, col, extendSelection);
+    setActiveCell(controller.activeCell);
+    setSelectedRange(controller.selectedRange);
+  }, [controller]);
+  const selectRange = useCallback((range) => {
+    controller.selectRange(range);
+    setSelectedRange(controller.selectedRange);
+  }, [controller]);
+  const startEditing = useCallback((row, col, initialVal) => {
+    controller.startEditing(row, col, initialVal);
+    setActiveCell(controller.activeCell);
+    setEditingCell(controller.editingCell);
+    setDraftValue(controller.draftValue);
+  }, [controller]);
+  const syncEditing = useCallback(() => {
+    setEditingCell(controller.editingCell);
+    setDraftValue(controller.draftValue);
+    setValidationPrompt(controller.validationPrompt);
+    setActiveCell(controller.activeCell);
+    setSelectedRange(controller.selectedRange);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const commitEditing = useCallback((val) => {
+    const result = controller.commitEditing(val);
+    syncEditing();
+    return result;
+  }, [controller, syncEditing]);
+  const commitCellInput = useCallback((rowId, colId, raw) => {
+    const result = controller.commitCellInput(rowId, colId, raw);
+    syncEditing();
+    return result;
+  }, [controller, syncEditing]);
+  const resolveValidationPrompt = useCallback((action) => {
+    controller.resolveValidationPrompt(action);
+    syncEditing();
+  }, [controller, syncEditing]);
+  const cancelEditing = useCallback(() => {
+    controller.cancelEditing();
+    setEditingCell(null);
+    setDraftValue("");
+  }, [controller]);
+  const moveCursor = useCallback((dir, extend = false) => {
+    controller.moveCursor(dir, extend);
+    setActiveCell(controller.activeCell);
+    setSelectedRange(controller.selectedRange);
+  }, [controller]);
+  const insertColumn = useCallback((index, config) => {
+    controller.insertColumn(index, config);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const deleteColumn = useCallback((colId) => {
+    controller.deleteColumn(colId);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const insertRow = useCallback((index, config) => {
+    controller.insertRow(index, config);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const deleteRow = useCallback((rowId) => {
+    controller.deleteRow(rowId);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const setColumnWidth = useCallback((colId, width) => {
+    controller.setColumnWidth(colId, width);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const autoFitColumnWidth = useCallback((colId, customWidth) => {
+    controller.autoFitColumnWidth(colId, customWidth);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const registerDataSource = useCallback((ds) => {
+    controller.registerDataSource(ds);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const setPrimaryDataSource = useCallback((id) => {
+    controller.setPrimaryDataSource(id);
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const recalculateAll = useCallback(() => {
+    controller.recalculateAll();
+    setDoc({ ...controller.document });
+  }, [controller]);
+  const undo = useCallback(() => {
+    controller.undo();
+    setDoc({ ...controller.document });
+    setActiveCell(controller.activeCell);
+    setSelectedRange(controller.selectedRange);
+  }, [controller]);
+  const redo = useCallback(() => {
+    controller.redo();
+    setDoc({ ...controller.document });
+    setActiveCell(controller.activeCell);
+    setSelectedRange(controller.selectedRange);
+  }, [controller]);
+  const tableActions = useMemo(() => bindSpreadsheetTableActions(controller), [controller]);
+  const viewModel = useMemo(() => controller.getViewModel(), [controller, doc]);
+  const sheets = useMemo(() => controller.getSheets(), [controller, doc]);
+  const names = useMemo(() => controller.getNames(), [controller, doc]);
+  const afterSheetSwitch = useCallback(() => {
+    setEditingCell(controller.editingCell);
+    setDraftValue(controller.draftValue);
+    setActiveCell(controller.activeCell);
+    setSelectedRange(controller.selectedRange);
+    setDoc({ ...controller.document });
+  }, [controller, setDraftValue]);
+  const workbookActions = useMemo(
+    () => ({
+      setActiveSheet: (idOrName) => {
+        const changed = controller.setActiveSheet(idOrName);
+        afterSheetSwitch();
+        return changed;
+      },
+      addSheet: (options2) => {
+        const id = controller.addSheet(options2);
+        afterSheetSwitch();
+        return id;
+      },
+      renameSheet: (idOrName, newName) => controller.renameSheet(idOrName, newName),
+      moveSheet: (idOrName, toIndex) => controller.moveSheet(idOrName, toIndex),
+      deleteSheet: (idOrName) => {
+        const deleted = controller.deleteSheet(idOrName);
+        afterSheetSwitch();
+        return deleted;
+      },
+      duplicateSheet: (idOrName, options2) => {
+        const id = controller.duplicateSheet(idOrName, options2);
+        afterSheetSwitch();
+        return id;
+      },
+      defineName: (name, refersTo, options2) => controller.defineName(name, refersTo, options2),
+      renameName: (oldName, newName, options2) => controller.renameName(oldName, newName, options2),
+      deleteName: (name, options2) => controller.deleteName(name, options2)
+    }),
+    [controller, afterSheetSwitch]
+  );
+  const conditionalFormatOverlay = useMemo(() => controller.getConditionalFormatOverlay(), [controller, doc]);
+  return {
+    document: doc,
+    activeCell,
+    selectedRange,
+    editingCell,
+    draftValue,
+    setDraftValue,
+    validationPrompt,
+    resolveValidationPrompt,
+    commitCellInput,
+    controller,
+    getCell: (rowId, colId) => controller.getCell(rowId, colId),
+    setCellValue,
+    selectCell,
+    selectRange,
+    startEditing,
+    commitEditing,
+    cancelEditing,
+    moveCursor,
+    insertColumn,
+    deleteColumn,
+    insertRow,
+    deleteRow,
+    setColumnWidth,
+    autoFitColumnWidth,
+    loadDocument: (document2) => {
+      controller.loadDocument(document2);
+      setDoc({ ...controller.document });
+      setActiveCell(null);
+      setSelectedRange(null);
+      setEditingCell(null);
+      setDraftValue("");
+    },
+    syncWithDataSource: () => {
+      controller.syncWithDataSource();
+      controller.recalculateAll();
+      setDoc({ ...controller.document });
+    },
+    registerDataSource,
+    setPrimaryDataSource,
+    recalculateAll,
+    exportToTsv: (range) => controller.exportToTsv(range),
+    importFromTsv: (data) => {
+      controller.importFromTsv(data);
+      setDoc({ ...controller.document });
+    },
+    ...tableActions,
+    viewModel,
+    /** The sheets in tab order (see `SpreadsheetController.getSheets`). */
+    sheets,
+    activeSheetId: controller.activeSheetId,
+    /** Defined names (see `SpreadsheetController.getNames`). */
+    names,
+    ...workbookActions,
+    conditionalFormatOverlay,
+    undo,
+    redo
+  };
+}
+
+// src/spreadsheet/SpreadsheetEditor.tsx
+import { useRef as useRef8, useState as useState8, useMemo as useMemo5, useEffect as useEffect6, useCallback as useCallback4 } from "react";
+import {
+  indexToColName,
+  getSpreadsheetMenuItems,
+  normalizeRange as normalizeRange2,
+  rangeContains,
+  formatCellForDisplay,
+  numberFormatColorToCss,
+  getConditionalFormatCss as getConditionalFormatCss2,
+  getConditionalFormatIcon,
+  getDataBarCss
+} from "@pixerate/editor/spreadsheet";
+
+// src/spreadsheet/SpreadsheetContextMenu.tsx
+import React, { useEffect, useLayoutEffect, useRef as useRef2, useState as useState2 } from "react";
+import { clampMenuPosition, runSpreadsheetMenuItem } from "@pixerate/editor/spreadsheet";
+import { jsx, jsxs } from "react/jsx-runtime";
+var VIEWPORT_MARGIN = 4;
+var SpreadsheetContextMenu = ({ items, x, y, onClose, onOpenPanel, ariaLabel = "Table actions" }) => {
+  const menuRef = useRef2(null);
+  const onCloseRef = useRef2(onClose);
+  onCloseRef.current = onClose;
+  const [position, setPosition] = useState2({ x, y });
+  useLayoutEffect(() => {
+    const menu = menuRef.current;
+    if (!menu || typeof window === "undefined") return;
+    const { width, height } = menu.getBoundingClientRect();
+    const next = clampMenuPosition(
+      { x, y },
+      { width, height },
+      { width: window.innerWidth, height: window.innerHeight },
+      VIEWPORT_MARGIN
+    );
+    setPosition((prev) => prev.x === next.x && prev.y === next.y ? prev : next);
+  }, [x, y, items]);
+  useEffect(() => {
+    const handlePointer = (e) => {
+      if (!menuRef.current?.contains(e.target)) onCloseRef.current();
+    };
+    const handleKey = (e) => {
+      if (e.key === "Escape") onCloseRef.current();
+    };
+    window.addEventListener("mousedown", handlePointer);
+    window.addEventListener("keydown", handleKey);
+    return () => {
+      window.removeEventListener("mousedown", handlePointer);
+      window.removeEventListener("keydown", handleKey);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: menuRef,
+      role: "menu",
+      "aria-label": ariaLabel,
+      className: "fixed z-50 min-w-[14rem] rounded-md border border-border bg-popover py-1 text-xs text-popover-foreground shadow-lg",
+      style: {
+        left: position.x,
+        top: position.y,
+        maxHeight: `calc(100vh - ${VIEWPORT_MARGIN * 2}px)`,
+        overflowY: "auto",
+        background: "var(--popover, var(--background, #fff))"
+      },
+      onContextMenu: (e) => e.preventDefault(),
+      onKeyDown: (e) => e.stopPropagation(),
+      children: items.map((item) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+        item.separatorBefore && /* @__PURE__ */ jsx("div", { role: "separator", className: "my-1 h-px bg-border" }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            role: "menuitem",
+            "data-action": item.id,
+            "data-checked": item.checked ? "" : void 0,
+            disabled: item.disabled,
+            className: `block w-full px-3 py-1 text-left hover:bg-muted disabled:cursor-default disabled:opacity-40 disabled:hover:bg-transparent ${item.checked ? "font-semibold" : ""}`,
+            onClick: () => {
+              onClose();
+              if (item.panel) onOpenPanel?.(item.panel);
+              else runSpreadsheetMenuItem(item);
+            },
+            children: item.label
+          }
+        )
+      ] }, item.id))
+    }
+  );
+};
+
+// src/spreadsheet/SpreadsheetGroupRow.tsx
+import React2 from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var formatSummary = (value) => value === null ? "\u2013" : String(value);
+var SpreadsheetGroupRow = ({
+  group,
+  columns,
+  groupColId,
+  onToggle,
+  trailingCell,
+  labelColumns = columns,
+  leadingColumns,
+  leftSpace = 0,
+  rightSpace = 0
+}) => {
+  const labelColId = labelColumns.some((c) => c.column.id === groupColId) ? groupColId : labelColumns[0]?.column.id;
+  const spacer = (key) => /* @__PURE__ */ jsx2("td", { "aria-hidden": "true", "data-spacer": "", style: { padding: 0 } }, key);
+  return /* @__PURE__ */ jsxs2("tr", { className: "border-b border-border bg-muted/40 font-semibold", "data-group-key": group.key, style: { height: 28 }, children: [
+    /* @__PURE__ */ jsx2("td", { className: "w-12 min-w-[3rem] sticky left-0 z-10 bg-muted border-r border-border text-center", children: /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        "aria-label": `${group.collapsed ? "Expand" : "Collapse"} group ${group.label}`,
+        "aria-expanded": !group.collapsed,
+        className: "h-5 w-5 rounded text-[10px] text-muted-foreground hover:bg-muted",
+        onClick: (e) => {
+          e.stopPropagation();
+          onToggle(group.key);
+        },
+        children: group.collapsed ? "\u25B8" : "\u25BE"
+      }
+    ) }),
+    columns.map(({ column }, i) => {
+      const summary = group.summaries[column.id];
+      const before = leadingColumns !== void 0 && i === leadingColumns && leftSpace > 0 ? spacer("space:left") : null;
+      return /* @__PURE__ */ jsxs2(React2.Fragment, { children: [
+        before,
+        /* @__PURE__ */ jsx2("td", { className: "border-r border-border px-2 py-1 truncate max-w-0 text-foreground", style: { maxWidth: 0, overflow: "hidden" }, children: column.id === labelColId ? /* @__PURE__ */ jsxs2("span", { className: "truncate", children: [
+          group.label,
+          " ",
+          /* @__PURE__ */ jsxs2("span", { className: "font-normal text-muted-foreground", children: [
+            "(",
+            group.rowIndices.length,
+            ")"
+          ] })
+        ] }) : summary !== void 0 ? /* @__PURE__ */ jsx2("span", { className: "truncate", "data-summary": column.id, children: formatSummary(summary) }) : null })
+      ] }, column.id);
+    }),
+    leadingColumns !== void 0 && leadingColumns >= columns.length && leftSpace > 0 && spacer("space:left"),
+    rightSpace > 0 && spacer("space:right"),
+    trailingCell && /* @__PURE__ */ jsx2("td", { className: "w-10 min-w-[2.5rem] bg-muted/10 border-r border-border" })
+  ] });
+};
+
+// src/spreadsheet/useSpreadsheetTableInteractions.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef3, useState as useState3 } from "react";
+import {
+  computeFillTarget,
+  normalizeRange
+} from "@pixerate/editor/spreadsheet";
+function gridHasFocus(grid) {
+  if (!grid || typeof document === "undefined") return false;
+  const active = document.activeElement;
+  if (!active || !grid.contains(active)) return false;
+  return !(active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement);
+}
+function useSpreadsheetClipboard(gridRef, state, readOnly) {
+  const stateRef = useRef3(state);
+  stateRef.current = state;
+  const readOnlyRef = useRef3(readOnly);
+  readOnlyRef.current = readOnly;
+  const copiedRef = useRef3(false);
+  useEffect2(() => {
+    if (typeof document === "undefined") return;
+    const handleCopy = (e) => {
+      const s = stateRef.current;
+      if (!gridHasFocus(gridRef.current) || s.editingCell || !e.clipboardData || !s.selectedRange) return;
+      for (const [type, data] of Object.entries(s.copyToClipboardData(s.selectedRange))) {
+        e.clipboardData.setData(type, data);
+      }
+      copiedRef.current = true;
+      e.preventDefault();
+    };
+    const handlePaste = (e) => {
+      const s = stateRef.current;
+      if (readOnlyRef.current || !gridHasFocus(gridRef.current) || s.editingCell || !e.clipboardData) return;
+      if (s.pasteClipboardData(e.clipboardData)) e.preventDefault();
+    };
+    document.addEventListener("copy", handleCopy);
+    document.addEventListener("paste", handlePaste);
+    return () => {
+      document.removeEventListener("copy", handleCopy);
+      document.removeEventListener("paste", handlePaste);
+    };
+  }, [gridRef]);
+  const copyShortcutFallback = useCallback2(() => {
+    copiedRef.current = false;
+    setTimeout(() => {
+      if (copiedRef.current) return;
+      const s = stateRef.current;
+      Promise.resolve(navigator.clipboard?.writeText(s.exportToTsv(s.selectedRange))).catch(() => {
+      });
+    }, 0);
+  }, []);
+  return { copyShortcutFallback };
+}
+function useFillHandle(state) {
+  const [drag, setDrag] = useState3(null);
+  const dragRef = useRef3(drag);
+  dragRef.current = drag;
+  const stateRef = useRef3(state);
+  stateRef.current = state;
+  const dragging = drag !== null;
+  useEffect2(() => {
+    if (!dragging) return;
+    const handleMouseUp = () => {
+      const current = dragRef.current;
+      setDrag(null);
+      if (current?.target) stateRef.current.autofill(current.source, current.target);
+    };
+    window.addEventListener("mouseup", handleMouseUp);
+    return () => window.removeEventListener("mouseup", handleMouseUp);
+  }, [dragging]);
+  const startFill = useCallback2((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    const range = stateRef.current.selectedRange;
+    if (range) setDrag({ source: normalizeRange(range), target: null });
+  }, []);
+  const extendFill = useCallback2((row, col) => {
+    const current = dragRef.current;
+    if (!current) return;
+    setDrag({ source: current.source, target: computeFillTarget(current.source, { row, col }) });
+  }, []);
+  return { fillTarget: drag?.target ?? null, isFilling: dragging, startFill, extendFill };
+}
+
+// src/spreadsheet/SpreadsheetValidationDialog.tsx
+import { useEffect as useEffect3, useRef as useRef4 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var SpreadsheetValidationDialog = ({ prompt, onResolve }) => {
+  const style = prompt.result.errorStyle ?? "stop";
+  const firstButton = useRef4(null);
+  useEffect3(() => {
+    firstButton.current?.focus();
+  }, [prompt]);
+  const buttons = style === "stop" ? [
+    { label: "Retry", action: "retry" },
+    { label: "Cancel", action: "cancel" }
+  ] : style === "warning" ? [
+    { label: "Yes", action: "accept" },
+    { label: "No", action: "retry" },
+    { label: "Cancel", action: "cancel" }
+  ] : [
+    { label: "OK", action: "accept" },
+    { label: "Cancel", action: "cancel" }
+  ];
+  const icon = style === "stop" ? "\u26D4" : style === "warning" ? "\u26A0" : "\u2139";
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      className: "fixed inset-0 z-[60] flex items-center justify-center bg-black/30",
+      onMouseDown: (e) => e.preventDefault(),
+      onKeyDown: (e) => {
+        e.stopPropagation();
+        if (e.key === "Escape") {
+          e.preventDefault();
+          onResolve("cancel");
+        }
+      },
+      children: /* @__PURE__ */ jsxs3(
+        "div",
+        {
+          role: "alertdialog",
+          "aria-modal": "true",
+          "aria-labelledby": "spreadsheet-validation-title",
+          "aria-describedby": "spreadsheet-validation-message",
+          "data-error-style": style,
+          className: "w-[22rem] max-w-[calc(100vw-2rem)] rounded-md border border-border bg-popover p-4 text-xs text-popover-foreground shadow-xl",
+          style: { background: "var(--popover, var(--background, #fff))" },
+          children: [
+            /* @__PURE__ */ jsxs3("div", { className: "flex items-start gap-3", children: [
+              /* @__PURE__ */ jsx3("span", { "aria-hidden": "true", className: "text-lg leading-none", children: icon }),
+              /* @__PURE__ */ jsxs3("div", { className: "min-w-0 flex-1", children: [
+                /* @__PURE__ */ jsx3("h2", { id: "spreadsheet-validation-title", className: "mb-1 text-sm font-semibold", children: prompt.result.title }),
+                /* @__PURE__ */ jsx3("p", { id: "spreadsheet-validation-message", className: "whitespace-pre-wrap", children: prompt.result.message }),
+                style === "warning" && /* @__PURE__ */ jsx3("p", { className: "mt-2", children: "Continue?" })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx3("div", { className: "mt-4 flex justify-end gap-2", children: buttons.map((button, i) => /* @__PURE__ */ jsx3(
+              "button",
+              {
+                ref: i === 0 ? firstButton : void 0,
+                type: "button",
+                "data-action": button.action,
+                className: `rounded border border-border px-3 py-1 ${i === 0 ? "bg-primary text-primary-foreground" : "hover:bg-muted"}`,
+                onClick: () => onResolve(button.action),
+                children: button.label
+              },
+              button.action
+            )) })
+          ]
+        }
+      )
+    }
+  );
+};
+
+// src/spreadsheet/SpreadsheetRulePanels.tsx
+import { useMemo as useMemo2, useState as useState4 } from "react";
+import {
+  CONDITIONAL_FORMAT_ICON_SETS,
+  CONDITIONAL_FORMAT_PRESETS,
+  CONDITIONAL_FORMAT_STYLE_PRESETS,
+  CONDITIONAL_FORMAT_TIME_PERIODS,
+  DATA_VALIDATION_ERROR_STYLE_OPTIONS,
+  DATA_VALIDATION_OPERATOR_OPTIONS,
+  DATA_VALIDATION_TYPE_OPTIONS,
+  createConditionalFormatRule,
+  describeConditionalFormat,
+  describeDataValidation,
+  formatRuleRanges,
+  getConditionalFormatCss,
+  parseRuleRanges
+} from "@pixerate/editor/spreadsheet";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var inputClass = "w-full rounded border border-border bg-background px-1.5 py-0.5 text-xs text-foreground";
+var buttonClass = "rounded border border-border px-2 py-0.5 hover:bg-muted disabled:opacity-40";
+function selectionText(range) {
+  return range ? formatRuleRanges([range]) : "A1";
+}
+var PanelFrame = ({
+  title,
+  label,
+  onClose,
+  children
+}) => /* @__PURE__ */ jsxs4(
+  "div",
+  {
+    role: "dialog",
+    "aria-label": label,
+    className: "fixed right-4 top-16 z-40 flex max-h-[calc(100vh-5rem)] w-80 flex-col overflow-y-auto rounded-md border border-border bg-popover p-3 text-xs text-popover-foreground shadow-lg",
+    style: { background: "var(--popover, var(--background, #fff))" },
+    onKeyDown: (e) => {
+      e.stopPropagation();
+      if (e.key === "Escape") onClose();
+    },
+    onContextMenu: (e) => e.stopPropagation(),
+    children: [
+      /* @__PURE__ */ jsxs4("div", { className: "mb-2 flex items-center justify-between", children: [
+        /* @__PURE__ */ jsx4("h2", { className: "text-sm font-semibold", children: title }),
+        /* @__PURE__ */ jsx4("button", { type: "button", "aria-label": "Close", className: "px-1 text-muted-foreground hover:text-foreground", onClick: onClose, children: "\u2715" })
+      ] }),
+      children
+    ]
+  }
+);
+function RuleSwatch({ rule }) {
+  if (rule.type === "colorScale") {
+    return /* @__PURE__ */ jsx4(
+      "span",
+      {
+        "aria-hidden": "true",
+        className: "inline-block h-3 w-6 shrink-0 rounded-sm border border-border",
+        style: { background: `linear-gradient(90deg, ${rule.stops.map((s) => s.color).join(", ")})` }
+      }
+    );
+  }
+  if (rule.type === "dataBar") {
+    return /* @__PURE__ */ jsx4("span", { "aria-hidden": "true", className: "inline-block h-3 w-6 shrink-0 rounded-sm", style: { background: rule.color ?? "#638ec6" } });
+  }
+  if (rule.type === "iconSet") return /* @__PURE__ */ jsx4("span", { "aria-hidden": "true", className: "shrink-0", children: "\u25CF" });
+  const css = getConditionalFormatCss(rule.style);
+  return /* @__PURE__ */ jsx4("span", { "aria-hidden": "true", className: "inline-flex h-4 w-6 shrink-0 items-center justify-center rounded-sm border border-border", style: css, children: "Aa" });
+}
+var SpreadsheetConditionalFormatPanel = ({ state, onClose }) => {
+  const rules = state.document.table?.conditionalFormats ?? [];
+  const [kind, setKind] = useState4("greaterThan");
+  const [appliesTo, setAppliesTo] = useState4(() => selectionText(state.selectedRange));
+  const [value, setValue] = useState4("");
+  const [value2, setValue2] = useState4("");
+  const [text, setText] = useState4("");
+  const [formula, setFormula] = useState4("=");
+  const [rank, setRank] = useState4("10");
+  const [period, setPeriod] = useState4("today");
+  const [iconSet, setIconSet] = useState4("3TrafficLights1");
+  const [color, setColor] = useState4("#638ec6");
+  const [styleId, setStyleId] = useState4(CONDITIONAL_FORMAT_STYLE_PRESETS[0].id);
+  const preset = useMemo2(() => CONDITIONAL_FORMAT_PRESETS.find((p) => p.kind === kind), [kind]);
+  const ranges = parseRuleRanges(appliesTo);
+  const add = () => {
+    if (!ranges) return;
+    state.addConditionalFormat(
+      createConditionalFormatRule({
+        kind,
+        ranges,
+        value,
+        value2,
+        text,
+        formula,
+        rank: Number(rank) || 10,
+        period,
+        iconSet,
+        color,
+        style: CONDITIONAL_FORMAT_STYLE_PRESETS.find((s) => s.id === styleId)?.style
+      })
+    );
+  };
+  return /* @__PURE__ */ jsxs4(PanelFrame, { title: "Conditional formatting", label: "Conditional formatting rules", onClose, children: [
+    /* @__PURE__ */ jsxs4("ol", { className: "mb-3 flex flex-col gap-1", "aria-label": "Rules in priority order", children: [
+      rules.length === 0 && /* @__PURE__ */ jsx4("li", { className: "text-muted-foreground", children: "No rules on this sheet." }),
+      rules.map((rule, i) => /* @__PURE__ */ jsxs4("li", { "data-rule-id": rule.id, className: "flex items-center gap-1.5 rounded border border-border px-1.5 py-1", children: [
+        /* @__PURE__ */ jsx4(RuleSwatch, { rule }),
+        /* @__PURE__ */ jsxs4("div", { className: "min-w-0 flex-1", children: [
+          /* @__PURE__ */ jsx4("div", { className: "truncate", title: describeConditionalFormat(rule), children: describeConditionalFormat(rule) }),
+          /* @__PURE__ */ jsx4("div", { className: "truncate font-mono text-[10px] text-muted-foreground", children: formatRuleRanges(rule.ranges) })
+        ] }),
+        /* @__PURE__ */ jsxs4("label", { className: "flex items-center gap-0.5 text-[10px]", title: "Stop if true", children: [
+          /* @__PURE__ */ jsx4(
+            "input",
+            {
+              type: "checkbox",
+              "aria-label": "Stop if true",
+              checked: !!rule.stopIfTrue,
+              onChange: (e) => state.updateConditionalFormat(rule.id, { stopIfTrue: e.target.checked })
+            }
+          ),
+          "Stop"
+        ] }),
+        /* @__PURE__ */ jsx4("button", { type: "button", "aria-label": "Move up", className: buttonClass, disabled: i === 0, onClick: () => state.moveConditionalFormat(rule.id, { by: -1 }), children: "\u25B2" }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Move down",
+            className: buttonClass,
+            disabled: i === rules.length - 1,
+            onClick: () => state.moveConditionalFormat(rule.id, { by: 1 }),
+            children: "\u25BC"
+          }
+        ),
+        /* @__PURE__ */ jsx4("button", { type: "button", "aria-label": "Delete rule", className: buttonClass, onClick: () => state.deleteConditionalFormat(rule.id), children: "\u2715" })
+      ] }, rule.id))
+    ] }),
+    /* @__PURE__ */ jsxs4("fieldset", { className: "flex flex-col gap-1.5 border-t border-border pt-2", children: [
+      /* @__PURE__ */ jsx4("legend", { className: "sr-only", children: "New rule" }),
+      /* @__PURE__ */ jsxs4("label", { className: "flex flex-col gap-0.5", children: [
+        "Format cells",
+        /* @__PURE__ */ jsx4("select", { "aria-label": "Rule type", className: inputClass, value: kind, onChange: (e) => setKind(e.target.value), children: CONDITIONAL_FORMAT_PRESETS.map((p) => /* @__PURE__ */ jsx4("option", { value: p.kind, children: p.label }, p.kind)) })
+      ] }),
+      preset.fields.includes("value") && /* @__PURE__ */ jsx4("input", { "aria-label": "Value", placeholder: "Value or =formula", className: inputClass, value, onChange: (e) => setValue(e.target.value) }),
+      preset.fields.includes("value2") && /* @__PURE__ */ jsx4("input", { "aria-label": "Second value", placeholder: "and", className: inputClass, value: value2, onChange: (e) => setValue2(e.target.value) }),
+      preset.fields.includes("text") && /* @__PURE__ */ jsx4("input", { "aria-label": "Text", placeholder: "Text", className: inputClass, value: text, onChange: (e) => setText(e.target.value) }),
+      preset.fields.includes("formula") && /* @__PURE__ */ jsx4("input", { "aria-label": "Formula", placeholder: "=$A1>10", className: inputClass, value: formula, onChange: (e) => setFormula(e.target.value) }),
+      preset.fields.includes("rank") && /* @__PURE__ */ jsx4("input", { "aria-label": "Rank", type: "number", min: 1, className: inputClass, value: rank, onChange: (e) => setRank(e.target.value) }),
+      preset.fields.includes("period") && /* @__PURE__ */ jsx4("select", { "aria-label": "Period", className: inputClass, value: period, onChange: (e) => setPeriod(e.target.value), children: CONDITIONAL_FORMAT_TIME_PERIODS.map((p) => /* @__PURE__ */ jsx4("option", { value: p.period, children: p.label }, p.period)) }),
+      preset.fields.includes("iconSet") && /* @__PURE__ */ jsx4("select", { "aria-label": "Icon set", className: inputClass, value: iconSet, onChange: (e) => setIconSet(e.target.value), children: CONDITIONAL_FORMAT_ICON_SETS.map((set) => /* @__PURE__ */ jsx4("option", { value: set, children: set }, set)) }),
+      preset.fields.includes("color") && /* @__PURE__ */ jsx4("input", { "aria-label": "Bar colour", type: "color", className: "h-6 w-12", value: color, onChange: (e) => setColor(e.target.value) }),
+      preset.usesStyle && /* @__PURE__ */ jsx4("select", { "aria-label": "Style", className: inputClass, value: styleId, onChange: (e) => setStyleId(e.target.value), children: CONDITIONAL_FORMAT_STYLE_PRESETS.map((s) => /* @__PURE__ */ jsx4("option", { value: s.id, children: s.label }, s.id)) }),
+      /* @__PURE__ */ jsxs4("label", { className: "flex flex-col gap-0.5", children: [
+        "Applies to",
+        /* @__PURE__ */ jsx4("input", { "aria-label": "Applies to", className: `${inputClass} font-mono`, value: appliesTo, onChange: (e) => setAppliesTo(e.target.value) })
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { className: "flex justify-between gap-2", children: [
+        /* @__PURE__ */ jsx4("button", { type: "button", className: buttonClass, onClick: () => setAppliesTo(selectionText(state.selectedRange)), children: "Use selection" }),
+        /* @__PURE__ */ jsx4("button", { type: "button", className: buttonClass, disabled: !ranges, onClick: add, children: "Add rule" })
+      ] })
+    ] })
+  ] });
+};
+var SpreadsheetDataValidationPanel = ({ state, onClose }) => {
+  const rules = state.document.table?.dataValidations ?? [];
+  const [type, setType] = useState4("list");
+  const [operator, setOperator] = useState4("between");
+  const [formula1, setFormula1] = useState4("");
+  const [formula2, setFormula2] = useState4("");
+  const [errorStyle, setErrorStyle] = useState4("stop");
+  const [errorMessage, setErrorMessage] = useState4("");
+  const [inputMessage, setInputMessage] = useState4("");
+  const [ignoreBlank, setIgnoreBlank] = useState4(true);
+  const [appliesTo, setAppliesTo] = useState4(() => selectionText(state.selectedRange));
+  const ranges = parseRuleRanges(appliesTo);
+  const usesOperator = type === "whole" || type === "decimal" || type === "date" || type === "time" || type === "textLength";
+  const needsTwo = usesOperator && (operator === "between" || operator === "notBetween");
+  const circles = state.controller.getInvalidDataCircles();
+  const apply = () => {
+    if (!ranges) return;
+    state.addDataValidation({
+      ranges,
+      type,
+      ...usesOperator ? { operator } : {},
+      ...formula1 ? { formula1 } : {},
+      ...needsTwo && formula2 ? { formula2 } : {},
+      errorStyle,
+      ...errorMessage ? { errorMessage } : {},
+      ...inputMessage ? { inputMessage } : {},
+      ignoreBlank
+    });
+  };
+  return /* @__PURE__ */ jsxs4(PanelFrame, { title: "Data validation", label: "Data validation rules", onClose, children: [
+    /* @__PURE__ */ jsxs4("ul", { className: "mb-3 flex flex-col gap-1", "aria-label": "Validation rules", children: [
+      rules.length === 0 && /* @__PURE__ */ jsx4("li", { className: "text-muted-foreground", children: "No validation on this sheet." }),
+      rules.map((rule) => /* @__PURE__ */ jsxs4("li", { "data-rule-id": rule.id, className: "flex items-center gap-1.5 rounded border border-border px-1.5 py-1", children: [
+        /* @__PURE__ */ jsxs4("div", { className: "min-w-0 flex-1", children: [
+          /* @__PURE__ */ jsx4("div", { className: "truncate", title: describeDataValidation(rule), children: describeDataValidation(rule) }),
+          /* @__PURE__ */ jsxs4("div", { className: "truncate font-mono text-[10px] text-muted-foreground", children: [
+            formatRuleRanges(rule.ranges),
+            " \xB7 ",
+            rule.errorStyle ?? "stop"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx4("button", { type: "button", "aria-label": "Delete rule", className: buttonClass, onClick: () => state.deleteDataValidation(rule.id), children: "\u2715" })
+      ] }, rule.id))
+    ] }),
+    /* @__PURE__ */ jsxs4("fieldset", { className: "flex flex-col gap-1.5 border-t border-border pt-2", children: [
+      /* @__PURE__ */ jsx4("legend", { className: "sr-only", children: "New validation" }),
+      /* @__PURE__ */ jsxs4("label", { className: "flex flex-col gap-0.5", children: [
+        "Allow",
+        /* @__PURE__ */ jsx4("select", { "aria-label": "Allow", className: inputClass, value: type, onChange: (e) => setType(e.target.value), children: DATA_VALIDATION_TYPE_OPTIONS.map((o) => /* @__PURE__ */ jsx4("option", { value: o.type, children: o.label }, o.type)) })
+      ] }),
+      usesOperator && /* @__PURE__ */ jsx4("select", { "aria-label": "Operator", className: inputClass, value: operator, onChange: (e) => setOperator(e.target.value), children: DATA_VALIDATION_OPERATOR_OPTIONS.map((o) => /* @__PURE__ */ jsx4("option", { value: o.operator, children: o.label }, o.operator)) }),
+      type !== "any" && /* @__PURE__ */ jsx4(
+        "input",
+        {
+          "aria-label": type === "list" ? "Source" : type === "custom" ? "Formula" : needsTwo ? "Minimum" : "Value",
+          placeholder: type === "list" ? "Low,Medium,High or =$H$1:$H$5" : type === "custom" ? "=A1>0" : "Value or =formula",
+          className: inputClass,
+          value: formula1,
+          onChange: (e) => setFormula1(e.target.value)
+        }
+      ),
+      needsTwo && /* @__PURE__ */ jsx4("input", { "aria-label": "Maximum", placeholder: "Maximum", className: inputClass, value: formula2, onChange: (e) => setFormula2(e.target.value) }),
+      /* @__PURE__ */ jsxs4("label", { className: "flex items-center gap-1", children: [
+        /* @__PURE__ */ jsx4("input", { type: "checkbox", checked: ignoreBlank, onChange: (e) => setIgnoreBlank(e.target.checked) }),
+        " Ignore blank"
+      ] }),
+      /* @__PURE__ */ jsx4("input", { "aria-label": "Input message", placeholder: "Input message (optional)", className: inputClass, value: inputMessage, onChange: (e) => setInputMessage(e.target.value) }),
+      /* @__PURE__ */ jsx4("div", { className: "flex gap-1", children: /* @__PURE__ */ jsx4("select", { "aria-label": "Error style", className: inputClass, value: errorStyle, onChange: (e) => setErrorStyle(e.target.value), children: DATA_VALIDATION_ERROR_STYLE_OPTIONS.map((o) => /* @__PURE__ */ jsx4("option", { value: o.style, children: o.label }, o.style)) }) }),
+      /* @__PURE__ */ jsx4("input", { "aria-label": "Error message", placeholder: "Error message (optional)", className: inputClass, value: errorMessage, onChange: (e) => setErrorMessage(e.target.value) }),
+      /* @__PURE__ */ jsxs4("label", { className: "flex flex-col gap-0.5", children: [
+        "Applies to",
+        /* @__PURE__ */ jsx4("input", { "aria-label": "Applies to", className: `${inputClass} font-mono`, value: appliesTo, onChange: (e) => setAppliesTo(e.target.value) })
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { className: "flex flex-wrap justify-between gap-2", children: [
+        /* @__PURE__ */ jsx4("button", { type: "button", className: buttonClass, onClick: () => setAppliesTo(selectionText(state.selectedRange)), children: "Use selection" }),
+        /* @__PURE__ */ jsx4("button", { type: "button", className: buttonClass, disabled: !ranges, onClick: () => ranges && ranges.forEach((r) => state.clearDataValidation(r)), children: "Clear" }),
+        /* @__PURE__ */ jsx4("button", { type: "button", className: buttonClass, disabled: !ranges, onClick: apply, children: "Apply" })
+      ] }),
+      /* @__PURE__ */ jsx4("button", { type: "button", className: buttonClass, "aria-pressed": circles, onClick: () => state.setInvalidDataCircles(!circles), children: circles ? "Clear validation circles" : "Circle invalid data" })
+    ] })
+  ] });
+};
+
+// src/spreadsheet/useSpreadsheetViewport.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useLayoutEffect as useLayoutEffect2, useMemo as useMemo3, useRef as useRef5, useState as useState5 } from "react";
+import {
+  fullSpreadsheetViewWindow,
+  getSpreadsheetScrollToCell,
+  getSpreadsheetViewWindow,
+  measureSpreadsheetView,
+  sameSpreadsheetViewWindow,
+  shouldVirtualizeSpreadsheet
+} from "@pixerate/editor/spreadsheet";
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect2 : useEffect4;
+function useSpreadsheetViewport(scrollRef, view, options = {}) {
+  const metrics = useMemo3(() => measureSpreadsheetView(view), [view]);
+  const virtual = shouldVirtualizeSpreadsheet(view, options.virtualize ?? "auto");
+  const [viewport, setViewport] = useState5({ scrollTop: 0, scrollLeft: 0, width: 0, height: 0 });
+  const windowOptions = useMemo3(
+    () => ({ merges: options.merges, overscanRows: options.overscanRows, overscanColumns: options.overscanColumns }),
+    [options.merges, options.overscanRows, options.overscanColumns]
+  );
+  const win = useMemo3(
+    () => virtual ? getSpreadsheetViewWindow(metrics, viewport, windowOptions) : fullSpreadsheetViewWindow(metrics),
+    [virtual, metrics, viewport, windowOptions]
+  );
+  const latest = useRef5({ metrics, viewport, virtual, windowOptions });
+  latest.current = { metrics, viewport, virtual, windowOptions };
+  const readViewport = useCallback3(() => {
+    const el = scrollRef.current;
+    if (!el) return null;
+    return { scrollTop: el.scrollTop, scrollLeft: el.scrollLeft, width: el.clientWidth, height: el.clientHeight };
+  }, [scrollRef]);
+  const updateViewport = useCallback3((next) => {
+    setViewport((prev) => {
+      const { metrics: m, virtual: v, windowOptions: o } = latest.current;
+      if (!v) return prev;
+      const same = prev.width === next.width && prev.height === next.height && sameSpreadsheetViewWindow(getSpreadsheetViewWindow(m, prev, o), getSpreadsheetViewWindow(m, next, o));
+      return same ? prev : next;
+    });
+  }, []);
+  const onScroll = useCallback3(() => {
+    const next = readViewport();
+    if (next) updateViewport(next);
+  }, [readViewport, updateViewport]);
+  useIsomorphicLayoutEffect(() => {
+    if (!virtual) return;
+    onScroll();
+    const el = scrollRef.current;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(() => onScroll());
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [virtual, onScroll, scrollRef]);
+  const activeRow = options.activeCell?.row;
+  const activeCol = options.activeCell?.col;
+  useIsomorphicLayoutEffect(() => {
+    if (!virtual || activeRow === void 0 || activeCol === void 0) return;
+    const el = scrollRef.current;
+    const current = latest.current.viewport;
+    const measured = readViewport();
+    const base = measured ? { ...measured, scrollTop: Math.max(measured.scrollTop, 0), scrollLeft: Math.max(measured.scrollLeft, 0) } : current;
+    const target = getSpreadsheetScrollToCell(latest.current.metrics, base, { row: activeRow, col: activeCol });
+    if (!target) return;
+    const next = { ...base, ...target };
+    if (el) {
+      if (target.scrollTop !== void 0) el.scrollTop = target.scrollTop;
+      if (target.scrollLeft !== void 0) el.scrollLeft = target.scrollLeft;
+    }
+    updateViewport(next);
+  }, [virtual, activeRow, activeCol]);
+  return { metrics, window: win, onScroll };
+}
+
+// src/spreadsheet/FormulaHints.tsx
+import { useEffect as useEffect5, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef6, useState as useState6 } from "react";
+import { applyFormulaSuggestion, getFormulaHints } from "@pixerate/editor/spreadsheet";
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var FormulaHints = ({ inputRef, value, onAccept, limit = 8, names }) => {
+  const [caret, setCaret] = useState6(null);
+  const [focused, setFocused] = useState6(false);
+  const [selected, setSelected] = useState6(0);
+  const [dismissed, setDismissed] = useState6(false);
+  const [position, setPosition] = useState6(null);
+  const pendingCaret = useRef6(null);
+  const hints = useMemo4(
+    () => getFormulaHints(value, caret ?? value.length, { limit, names }),
+    [value, caret, limit, names]
+  );
+  const suggestions = dismissed ? [] : hints.suggestions;
+  const selectedIndex = Math.max(0, Math.min(selected, suggestions.length - 1));
+  const visible = focused && value.trimStart().startsWith("=") && (suggestions.length > 0 || !!hints.activeCall);
+  const latest = useRef6({ suggestions, selected: selectedIndex, value, caret, onAccept });
+  latest.current = { suggestions, selected: selectedIndex, value, caret, onAccept };
+  const accept = (index) => {
+    const { suggestions: list, value: current, caret: at, onAccept: commit } = latest.current;
+    const suggestion = list[index];
+    if (!suggestion) return;
+    const next = applyFormulaSuggestion(current, at ?? current.length, suggestion);
+    pendingCaret.current = next.caret;
+    commit(next.value);
+  };
+  useEffect5(() => {
+    const input = inputRef.current;
+    if (!input) return;
+    const syncCaret = () => setCaret(input.selectionStart ?? input.value.length);
+    const onInput = () => {
+      setDismissed(false);
+      setSelected(0);
+      syncCaret();
+    };
+    const onFocus = () => {
+      setFocused(true);
+      syncCaret();
+    };
+    const onBlur = () => setFocused(false);
+    const onKeyDown = (e) => {
+      const { suggestions: list } = latest.current;
+      if (list.length === 0) return;
+      if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+        e.preventDefault();
+        e.stopPropagation();
+        const step = e.key === "ArrowDown" ? 1 : -1;
+        setSelected((i) => (i + step + list.length) % list.length);
+      } else if (e.key === "Tab" && !e.shiftKey) {
+        e.preventDefault();
+        e.stopPropagation();
+        accept(latest.current.selected);
+      } else if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        setDismissed(true);
+      }
+    };
+    input.addEventListener("input", onInput);
+    input.addEventListener("keyup", syncCaret);
+    input.addEventListener("click", syncCaret);
+    input.addEventListener("select", syncCaret);
+    input.addEventListener("focus", onFocus);
+    input.addEventListener("blur", onBlur);
+    input.addEventListener("keydown", onKeyDown);
+    if (typeof document !== "undefined" && document.activeElement === input) onFocus();
+    return () => {
+      input.removeEventListener("input", onInput);
+      input.removeEventListener("keyup", syncCaret);
+      input.removeEventListener("click", syncCaret);
+      input.removeEventListener("select", syncCaret);
+      input.removeEventListener("focus", onFocus);
+      input.removeEventListener("blur", onBlur);
+      input.removeEventListener("keydown", onKeyDown);
+    };
+  }, [inputRef]);
+  useLayoutEffect3(() => {
+    const input = inputRef.current;
+    const at = pendingCaret.current;
+    if (!input || at === null || input.value !== value) return;
+    pendingCaret.current = null;
+    input.setSelectionRange(at, at);
+    setCaret(at);
+    setSelected(0);
+  }, [value, inputRef]);
+  useLayoutEffect3(() => {
+    const input = inputRef.current;
+    if (!visible || !input) return;
+    const rect = input.getBoundingClientRect();
+    setPosition({ top: rect.bottom + 2, left: rect.left, width: rect.width });
+  }, [visible, value, inputRef]);
+  if (!visible) return null;
+  const { activeCall } = hints;
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      "data-formula-hints": "",
+      className: "rounded-md border border-border bg-popover text-popover-foreground shadow-md text-xs font-sans overflow-hidden",
+      style: {
+        position: "fixed",
+        top: position?.top ?? 0,
+        left: position?.left ?? 0,
+        minWidth: Math.max(260, position?.width ?? 0),
+        maxWidth: 440,
+        zIndex: 50,
+        visibility: position ? "visible" : "hidden"
+      },
+      onMouseDown: (e) => e.preventDefault(),
+      children: [
+        activeCall && /* @__PURE__ */ jsxs5("div", { "data-formula-signature": "", className: "px-2 py-1.5 border-b border-border bg-muted/30", children: [
+          /* @__PURE__ */ jsx5("div", { className: "font-mono", children: activeCall.parts.map((part, i) => /* @__PURE__ */ jsx5(
+            "span",
+            {
+              "data-active": part.active ? "" : void 0,
+              className: part.active ? "font-bold text-primary underline" : "",
+              children: part.text
+            },
+            i
+          )) }),
+          /* @__PURE__ */ jsx5("div", { className: "mt-0.5 text-muted-foreground", children: activeCall.argument ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+            /* @__PURE__ */ jsx5("span", { className: "font-semibold", children: activeCall.argument.name }),
+            ": ",
+            activeCall.argument.description
+          ] }) : activeCall.description })
+        ] }),
+        suggestions.length > 0 && /* @__PURE__ */ jsx5("ul", { role: "listbox", "aria-label": "Formula suggestions", className: "max-h-64 overflow-auto py-1 m-0 list-none p-0", children: suggestions.map((s, i) => /* @__PURE__ */ jsxs5(
+          "li",
+          {
+            role: "option",
+            "aria-selected": i === selectedIndex,
+            className: `cursor-pointer px-2 py-1 ${i === selectedIndex ? "bg-primary/10" : "hover:bg-muted/50"}`,
+            onMouseEnter: () => setSelected(i),
+            onMouseDown: (e) => {
+              e.preventDefault();
+              accept(i);
+            },
+            children: [
+              /* @__PURE__ */ jsx5("div", { className: "font-mono font-semibold text-foreground", children: s.signature }),
+              /* @__PURE__ */ jsx5("div", { className: "text-muted-foreground truncate", children: s.description })
+            ]
+          },
+          `${s.kind ?? "fn"}:${s.name}`
+        )) })
+      ]
+    }
+  );
+};
+
+// src/spreadsheet/SheetTabs.tsx
+import { useRef as useRef7, useState as useState7 } from "react";
+import { getSheetTabMenuItems, sheetDropIndex } from "@pixerate/editor/spreadsheet";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var SheetTabs = ({ state, readOnly = false, className = "" }) => {
+  const { controller, sheets } = state;
+  const [renaming, setRenaming] = useState7(null);
+  const [error, setError] = useState7(null);
+  const [menu, setMenu] = useState7(null);
+  const dragFrom = useRef7(null);
+  const [dropTarget, setDropTarget] = useState7(null);
+  const commitRename = (cancelOnError) => {
+    if (!renaming) return;
+    const sheet = sheets.find((s) => s.id === renaming.id);
+    const name = renaming.draft.trim();
+    if (!sheet || !name || name === sheet.name) {
+      setRenaming(null);
+      setError(null);
+      return;
+    }
+    try {
+      state.renameSheet(renaming.id, name);
+      setRenaming(null);
+      setError(null);
+    } catch (err) {
+      setError(err?.message ?? String(err));
+      if (cancelOnError) setRenaming(null);
+    }
+  };
+  const dropAfter = (e) => {
+    const rect = e.currentTarget.getBoundingClientRect();
+    return e.clientX > rect.left + rect.width / 2;
+  };
+  return /* @__PURE__ */ jsxs6("div", { className: `flex flex-col ${className}`, "data-sheet-tabs": "", children: [
+    /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        role: "tablist",
+        "aria-label": "Sheets",
+        className: "flex items-center gap-0.5 overflow-x-auto border-t border-border bg-muted px-1 py-1 text-xs",
+        children: [
+          sheets.map(
+            (sheet, index) => renaming?.id === sheet.id ? /* @__PURE__ */ jsx6(
+              "input",
+              {
+                "aria-label": "Sheet name",
+                autoFocus: true,
+                className: "w-32 rounded border border-primary bg-background px-2 py-0.5 text-xs outline-none",
+                value: renaming.draft,
+                onChange: (e) => setRenaming({ id: sheet.id, draft: e.target.value }),
+                onFocus: (e) => e.currentTarget.select(),
+                onKeyDown: (e) => {
+                  e.stopPropagation();
+                  if (e.key === "Enter") commitRename(false);
+                  else if (e.key === "Escape") {
+                    setRenaming(null);
+                    setError(null);
+                  }
+                },
+                onBlur: () => commitRename(true)
+              },
+              sheet.id
+            ) : /* @__PURE__ */ jsx6(
+              "button",
+              {
+                type: "button",
+                role: "tab",
+                "aria-selected": sheet.active,
+                "data-sheet-id": sheet.id,
+                draggable: !readOnly,
+                title: readOnly ? sheet.name : `${sheet.name} \u2014 double-click to rename, drag to move`,
+                className: `whitespace-nowrap rounded px-3 py-0.5 ${sheet.active ? "bg-background font-semibold text-foreground shadow-sm" : "text-muted-foreground hover:bg-background/60"} ${dropTarget?.index === index ? dropTarget.after ? "border-r-2 border-primary" : "border-l-2 border-primary" : ""}`,
+                onClick: () => state.setActiveSheet(sheet.id),
+                onDoubleClick: () => {
+                  if (readOnly) return;
+                  setError(null);
+                  setRenaming({ id: sheet.id, draft: sheet.name });
+                },
+                onContextMenu: (e) => {
+                  if (readOnly) return;
+                  e.preventDefault();
+                  setMenu({ x: e.clientX, y: e.clientY, items: getSheetTabMenuItems(controller, sheet.id, { onError: setError }) });
+                },
+                onDragStart: (e) => {
+                  dragFrom.current = index;
+                  e.dataTransfer?.setData("text/plain", sheet.id);
+                  if (e.dataTransfer) e.dataTransfer.effectAllowed = "move";
+                },
+                onDragOver: (e) => {
+                  if (dragFrom.current === null) return;
+                  e.preventDefault();
+                  const after = dropAfter(e);
+                  setDropTarget((prev) => prev?.index === index && prev.after === after ? prev : { index, after });
+                },
+                onDragLeave: () => setDropTarget(null),
+                onDrop: (e) => {
+                  e.preventDefault();
+                  const from = dragFrom.current;
+                  dragFrom.current = null;
+                  setDropTarget(null);
+                  if (from === null) return;
+                  state.moveSheet(sheets[from].id, sheetDropIndex(from, index, dropAfter(e)));
+                },
+                onDragEnd: () => {
+                  dragFrom.current = null;
+                  setDropTarget(null);
+                },
+                children: sheet.name
+              },
+              sheet.id
+            )
+          ),
+          !readOnly && /* @__PURE__ */ jsx6(
+            "button",
+            {
+              type: "button",
+              "aria-label": "Add sheet",
+              title: "Add sheet",
+              className: "rounded px-2 py-0.5 text-muted-foreground hover:bg-background/60",
+              onClick: () => {
+                setError(null);
+                state.addSheet();
+              },
+              children: "+"
+            }
+          )
+        ]
+      }
+    ),
+    error && /* @__PURE__ */ jsx6("div", { role: "alert", className: "px-2 py-1 text-xs text-destructive", children: error }),
+    menu && /* @__PURE__ */ jsx6(
+      SpreadsheetContextMenu,
+      {
+        items: menu.items,
+        x: menu.x,
+        y: menu.y,
+        ariaLabel: "Sheet actions",
+        onClose: () => setMenu(null)
+      }
+    )
+  ] });
+};
+
+// src/spreadsheet/SpreadsheetEditor.tsx
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var COLUMN_HEADER_HEIGHT = 28;
+var ROW_HEADER_WIDTH = 48;
+function frozenCellStyle(viewRow, viewCol) {
+  if (!viewRow.frozen && !viewCol.frozen) return void 0;
+  return {
+    position: "sticky",
+    ...viewRow.frozen ? { top: COLUMN_HEADER_HEIGHT + viewRow.stickyTop } : {},
+    ...viewCol.frozen ? { left: ROW_HEADER_WIDTH + viewCol.stickyLeft } : {},
+    zIndex: viewRow.frozen && viewCol.frozen ? 14 : viewRow.frozen ? 12 : 11,
+    background: "var(--background, #fff)"
+  };
+}
+var coordKey = (cell) => cell ? `${indexToColName(cell.col)}${cell.row + 1}` : "";
+function spillBorderStyle(range, row, col) {
+  const line = "1px solid color-mix(in srgb, var(--primary, #6366f1) 60%, transparent)";
+  return {
+    position: "absolute",
+    inset: 0,
+    pointerEvents: "none",
+    zIndex: 5,
+    borderTop: row === range.startRow ? line : void 0,
+    borderBottom: row === range.endRow ? line : void 0,
+    borderLeft: col === range.startCol ? line : void 0,
+    borderRight: col === range.endCol ? line : void 0
+  };
+}
+function CellText({ cell, conditional }) {
+  const shown = formatCellForDisplay(cell);
+  const color = conditional?.color ?? (shown.color ? numberFormatColorToCss(shown.color) : void 0);
+  const decorated = !!conditional?.dataBar || !!conditional?.icon;
+  const text = /* @__PURE__ */ jsx7(
+    "span",
+    {
+      className: `truncate block max-w-full ${cell.error ? "text-destructive font-semibold" : ""}`,
+      title: cell.error ? cell.errorMessage ?? cell.error : void 0,
+      "data-numeric": shown.numeric ? "" : void 0,
+      style: shown.numeric || color || decorated ? {
+        ...decorated ? { position: "relative" } : {},
+        ...conditional?.icon ? { flex: 1, minWidth: 0 } : {},
+        ...shown.numeric ? { textAlign: "right" } : {},
+        ...color ? { color } : {}
+      } : void 0,
+      children: conditional?.hideValue ? "" : shown.text
+    }
+  );
+  if (!conditional || !decorated) return text;
+  const icon = conditional.icon ? getConditionalFormatIcon(conditional.icon.set, conditional.icon.index) : null;
+  return /* @__PURE__ */ jsxs7(Fragment2, { children: [
+    conditional.dataBar && /* @__PURE__ */ jsx7("span", { "aria-hidden": "true", className: "spreadsheet-data-bar", style: getDataBarCss(conditional.dataBar) }),
+    icon ? /* @__PURE__ */ jsxs7("span", { className: "flex items-center gap-1 min-w-0", style: { position: "relative" }, children: [
+      /* @__PURE__ */ jsx7("span", { className: "spreadsheet-cf-icon shrink-0", role: "img", "aria-label": icon.label, "data-icon": conditional.icon.id, style: { color: icon.color }, children: icon.glyph }),
+      text
+    ] }) : text
+  ] });
+}
+var SpreadsheetEditor = ({
+  state: externalState,
+  readOnly = false,
+  customCellRenderer,
+  onAddColumnClick,
+  onColumnHeaderClick,
+  onColumnResize,
+  showSheetTabs = false,
+  virtualize = "auto"
+}) => {
+  const defaultState = useSpreadsheetEditor();
+  const state = externalState || defaultState;
+  const gridRef = useRef8(null);
+  const scrollRef = useRef8(null);
+  const formulaBarRef = useRef8(null);
+  const cellInputRef = useRef8(null);
+  const [resizingColId, setResizingColId] = useState8(null);
+  const [hoveredColId, setHoveredColId] = useState8(null);
+  const [resizeStartX, setResizeStartX] = useState8(0);
+  const [resizeStartWidth, setResizeStartWidth] = useState8(0);
+  const view = state.viewModel;
+  const { window: viewWindow, onScroll: handleGridScroll } = useSpreadsheetViewport(scrollRef, view, {
+    virtualize,
+    merges: state.document.table?.merges,
+    activeCell: state.activeCell
+  });
+  const columnSlots = useMemo5(() => {
+    const col = (viewCol) => ({ kind: "col", viewCol });
+    if (!viewWindow.virtual) return view.columns.map(col);
+    const slots = view.columns.slice(0, viewWindow.frozenColumns).map(col);
+    if (viewWindow.leftSpace > 0) slots.push({ kind: "space", key: "space:left", width: viewWindow.leftSpace });
+    for (let i = viewWindow.colStart; i < viewWindow.colEnd; i++) slots.push(col(view.columns[i]));
+    if (viewWindow.rightSpace > 0) slots.push({ kind: "space", key: "space:right", width: viewWindow.rightSpace });
+    return slots;
+  }, [view, viewWindow]);
+  const renderedColumns = useMemo5(
+    () => columnSlots.flatMap((slot) => slot.kind === "col" ? [slot.viewCol] : []),
+    [columnSlots]
+  );
+  const rowSlots = useMemo5(() => {
+    const row = (viewRow) => ({ kind: "row", viewRow });
+    if (!viewWindow.virtual) return view.rows.map(row);
+    const slots = view.rows.slice(0, viewWindow.frozenRows).map(row);
+    if (viewWindow.topSpace > 0) slots.push({ kind: "space", key: "space:top", height: viewWindow.topSpace });
+    for (let i = viewWindow.rowStart; i < viewWindow.rowEnd; i++) slots.push(row(view.rows[i]));
+    if (viewWindow.bottomSpace > 0) slots.push({ kind: "space", key: "space:bottom", height: viewWindow.bottomSpace });
+    return slots;
+  }, [view, viewWindow]);
+  const { copyShortcutFallback } = useSpreadsheetClipboard(gridRef, state, readOnly);
+  const { fillTarget, startFill, extendFill } = useFillHandle(state);
+  const [menu, setMenu] = useState8(null);
+  const [panel, setPanel] = useState8(null);
+  const [listMenu, setListMenu] = useState8(null);
+  const overlay = state.conditionalFormatOverlay;
+  const filter = state.document.table?.filter;
+  const filteredColIds = useMemo5(
+    () => new Set(filter?.enabled ? filter.rules.map((r) => r.colId) : []),
+    [filter]
+  );
+  const handleCellContextMenu = useCallback4((rIdx, cIdx, e) => {
+    if (readOnly) return;
+    e.preventDefault();
+    if (state.editingCell) state.commitEditing();
+    if (!state.selectedRange || !rangeContains(state.selectedRange, rIdx, cIdx)) {
+      state.selectCell(rIdx, cIdx);
+    }
+    setMenu({ x: e.clientX, y: e.clientY, items: getSpreadsheetMenuItems(state.controller, { row: rIdx, col: cIdx }) });
+  }, [readOnly, state]);
+  const nameSuggestions = useMemo5(
+    () => state.controller.getNameSuggestions(),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [state.controller, state.document]
+  );
+  const activeRawValue = useMemo5(() => {
+    if (!state.activeCell) return "";
+    const row = state.document.rows[state.activeCell.row];
+    const col = state.document.columns[state.activeCell.col];
+    if (!row || !col) return "";
+    return state.getCell(row.id, col.id).raw;
+  }, [state.activeCell, state.document]);
+  const activeSpill = useMemo5(
+    () => state.activeCell ? state.controller.getSpillAt(state.activeCell.row, state.activeCell.col) : null,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [state.controller, state.activeCell, state.document]
+  );
+  const spillFormula = activeSpill && !activeRawValue && activeSpill.key !== coordKey(state.activeCell) ? activeSpill.formula : "";
+  const coordLabel = useMemo5(() => {
+    if (!state.activeCell) return "--";
+    const colName = indexToColName(state.activeCell.col);
+    return `${colName}${state.activeCell.row + 1}`;
+  }, [state.activeCell]);
+  const [formulaDraft, setFormulaDraft] = useState8(null);
+  const activeColumn = state.activeCell ? state.document.columns[state.activeCell.col] : void 0;
+  const formulaBarReadOnly = readOnly || !state.activeCell || !!activeColumn?.readOnly;
+  useEffect6(() => {
+    setFormulaDraft(null);
+  }, [state.activeCell?.row, state.activeCell?.col]);
+  const commitFormulaBar = () => {
+    if (state.editingCell) {
+      state.commitEditing();
+      return;
+    }
+    if (formulaDraft === null || !state.activeCell) return;
+    const row = state.document.rows[state.activeCell.row];
+    const col = state.document.columns[state.activeCell.col];
+    if (row && col && !formulaBarReadOnly && formulaDraft !== activeRawValue) {
+      state.commitCellInput(row.id, col.id, formulaDraft);
+    }
+    setFormulaDraft(null);
+  };
+  const handleCellClick = useCallback4((rIdx, cIdx, e) => {
+    if (state.editingCell && (state.editingCell.row !== rIdx || state.editingCell.col !== cIdx)) {
+      state.commitEditing();
+    }
+    state.selectCell(rIdx, cIdx, e.shiftKey);
+  }, [state]);
+  const handleCellDblClick = useCallback4((rIdx, cIdx) => {
+    if (readOnly) return;
+    const col = state.document.columns[cIdx];
+    if (col?.readOnly) return;
+    state.startEditing(rIdx, cIdx);
+  }, [readOnly, state]);
+  const handleKeyDown = useCallback4((e) => {
+    if (state.editingCell) {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        if (state.commitEditing().status !== "committed") return;
+        state.moveCursor("down");
+      } else if (e.key === "Escape") {
+        e.preventDefault();
+        state.cancelEditing();
+      } else if (e.key === "Tab") {
+        e.preventDefault();
+        if (state.commitEditing().status !== "committed") return;
+        state.moveCursor(e.shiftKey ? "left" : "right");
+      } else {
+        return;
+      }
+      gridRef.current?.focus();
+      return;
+    }
+    if (!state.activeCell) return;
+    if (e.altKey && e.key === "ArrowDown") {
+      e.preventDefault();
+      openListMenu(state.activeCell.row, state.activeCell.col);
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      state.moveCursor("up", e.shiftKey);
+    } else if (e.key === "ArrowDown") {
+      e.preventDefault();
+      state.moveCursor("down", e.shiftKey);
+    } else if (e.key === "ArrowLeft") {
+      e.preventDefault();
+      state.moveCursor("left", e.shiftKey);
+    } else if (e.key === "ArrowRight") {
+      e.preventDefault();
+      state.moveCursor("right", e.shiftKey);
+    } else if (e.key === "Tab") {
+      e.preventDefault();
+      state.moveCursor(e.shiftKey ? "left" : "right");
+    } else if (e.key === "Enter") {
+      e.preventDefault();
+      const col = state.document.columns[state.activeCell.col];
+      if (!readOnly && !col?.readOnly) {
+        state.startEditing();
+      }
+    } else if (e.key === "Backspace" || e.key === "Delete") {
+      if (readOnly) return;
+      const row = state.document.rows[state.activeCell.row];
+      const col = state.document.columns[state.activeCell.col];
+      if (row && col && !col.readOnly) {
+        e.preventDefault();
+        state.setCellValue(row.id, col.id, "");
+      }
+    } else if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "z") {
+      e.preventDefault();
+      if (e.shiftKey) {
+        state.redo();
+      } else {
+        state.undo();
+      }
+    } else if (e.ctrlKey && !e.metaKey && e.key.toLowerCase() === "y") {
+      e.preventDefault();
+      state.redo();
+    } else if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "c") {
+      copyShortcutFallback();
+    } else if (!readOnly && e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+      const col = state.document.columns[state.activeCell.col];
+      if (!col?.readOnly) {
+        e.preventDefault();
+        state.startEditing(state.activeCell.row, state.activeCell.col, e.key);
+      }
+    }
+  }, [readOnly, state, copyShortcutFallback]);
+  const activeListValues = useMemo5(
+    () => state.activeCell && !readOnly ? state.controller.getValidationListValues(state.activeCell.row, state.activeCell.col) : null,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [state.controller, state.activeCell, state.document, readOnly]
+  );
+  const activeRule = useMemo5(
+    () => state.activeCell ? state.controller.getDataValidationAt(state.activeCell.row, state.activeCell.col) : void 0,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [state.controller, state.activeCell, state.document]
+  );
+  const inputMessage = activeRule && activeRule.showInputMessage !== false && (activeRule.inputTitle || activeRule.inputMessage) ? activeRule : null;
+  function openListMenu(row, col, anchor) {
+    if (readOnly || state.document.columns[col]?.readOnly) return;
+    const values = state.controller.getValidationListValues(row, col);
+    if (!values) return;
+    const td = anchor ?? gridRef.current?.querySelector(`td[data-row="${row}"][data-col="${col}"]`);
+    const rect = td?.getBoundingClientRect();
+    setListMenu({ x: rect ? rect.left : 0, y: rect ? rect.bottom : 0, row, col, values });
+  }
+  useEffect6(() => {
+    if (!listMenu) return;
+    const close = (e) => {
+      if (!e.target?.closest?.('[aria-label="Allowed values"], .spreadsheet-list-arrow')) setListMenu(null);
+    };
+    window.addEventListener("mousedown", close);
+    return () => window.removeEventListener("mousedown", close);
+  }, [listMenu]);
+  const chooseListValue = (value) => {
+    if (!listMenu) return;
+    const row = state.document.rows[listMenu.row];
+    const col = state.document.columns[listMenu.col];
+    setListMenu(null);
+    if (row && col) state.commitCellInput(row.id, col.id, value);
+    gridRef.current?.focus();
+  };
+  const resolveValidation = (action) => {
+    state.resolveValidationPrompt(action);
+    requestAnimationFrame(() => {
+      if (cellInputRef.current) cellInputRef.current.focus();
+      else gridRef.current?.focus();
+    });
+  };
+  const stateRef = useRef8(state);
+  stateRef.current = state;
+  const onColumnResizeRef = useRef8(onColumnResize);
+  onColumnResizeRef.current = onColumnResize;
+  useEffect6(() => {
+    if (!resizingColId) return;
+    if (typeof document !== "undefined") {
+      document.body.style.cursor = "col-resize";
+      document.body.style.userSelect = "none";
+    }
+    let rafId = null;
+    let pendingWidth = resizeStartWidth;
+    let hasDragged = false;
+    const handleMouseMove = (e) => {
+      const delta = e.clientX - resizeStartX;
+      if (Math.abs(delta) > 2) {
+        hasDragged = true;
+      }
+      pendingWidth = Math.max(30, resizeStartWidth + delta);
+      if (rafId === null) {
+        rafId = requestAnimationFrame(() => {
+          rafId = null;
+          stateRef.current.setColumnWidth(resizingColId, pendingWidth);
+        });
+      }
+    };
+    const handleMouseUp = () => {
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+      if (hasDragged) {
+        stateRef.current.setColumnWidth(resizingColId, pendingWidth);
+        onColumnResizeRef.current?.(resizingColId, pendingWidth);
+      }
+      setResizingColId(null);
+      if (typeof document !== "undefined") {
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+      }
+    };
+    window.addEventListener("mousemove", handleMouseMove);
+    window.addEventListener("mouseup", handleMouseUp);
+    return () => {
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+      }
+      if (typeof document !== "undefined") {
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+      }
+      window.removeEventListener("mousemove", handleMouseMove);
+      window.removeEventListener("mouseup", handleMouseUp);
+    };
+  }, [resizingColId, resizeStartX, resizeStartWidth]);
+  const measureElementContentWidth = useCallback4((el, container) => {
+    if (typeof document === "undefined") return 0;
+    let maxW = el.scrollWidth || 0;
+    const firstChild = el.firstElementChild;
+    if (firstChild && firstChild.scrollWidth > maxW) {
+      maxW = firstChild.scrollWidth;
+    }
+    const truncated = el.querySelectorAll(".truncate, [title], span, div");
+    truncated.forEach((node) => {
+      if (node.scrollWidth > maxW) {
+        maxW = node.scrollWidth;
+      }
+    });
+    try {
+      const clone = firstChild ? firstChild.cloneNode(true) : el.cloneNode(true);
+      clone.style.cssText = `
+        position: absolute !important;
+        visibility: hidden !important;
+        width: max-content !important;
+        min-width: max-content !important;
+        max-width: none !important;
+        overflow: visible !important;
+        white-space: nowrap !important;
+        pointer-events: none !important;
+        top: -9999px !important;
+        left: -9999px !important;
+      `;
+      const allNodes = clone.querySelectorAll("*");
+      allNodes.forEach((node) => {
+        node.style.maxWidth = "none";
+        node.style.overflow = "visible";
+        node.style.textOverflow = "clip";
+        node.style.whiteSpace = "nowrap";
+        if (node.classList.contains("truncate") || node.classList.contains("min-w-0") || node.classList.contains("w-full") || node.classList.contains("max-w-0") || node.classList.contains("flex-1")) {
+          node.style.width = "max-content";
+          node.style.minWidth = "max-content";
+        }
+      });
+      container.appendChild(clone);
+      const rect = clone.getBoundingClientRect();
+      container.removeChild(clone);
+      if (rect.width > maxW) {
+        maxW = rect.width;
+      }
+    } catch {
+    }
+    return maxW;
+  }, []);
+  const autoFitColumn = useCallback4((colId, colIndex) => {
+    const col = state.document.columns.find((c) => c.id === colId);
+    if (!col) return;
+    let calculatedWidth = 0;
+    if (gridRef.current && typeof document !== "undefined") {
+      const table = gridRef.current.querySelector("table");
+      if (table) {
+        const th = table.querySelector(`thead th[data-col="${colIndex}"]`);
+        if (th) {
+          const headerInner = th.firstElementChild || th;
+          const headerW = measureElementContentWidth(headerInner, gridRef.current);
+          calculatedWidth = Math.max(calculatedWidth, headerW + 28);
+        }
+        const rows = table.querySelectorAll("tbody tr");
+        const sampleLimit = Math.min(rows.length, 150);
+        for (let r = 0; r < sampleLimit; r++) {
+          const tr = rows[r];
+          const td = tr.querySelector(`td[data-col="${colIndex}"][colspan="1"]`);
+          if (td) {
+            const cellW = measureElementContentWidth(td, gridRef.current);
+            calculatedWidth = Math.max(calculatedWidth, cellW + 20);
+          }
+        }
+      }
+    }
+    if (calculatedWidth > 0) {
+      const finalWidth = Math.min(600, Math.max(50, Math.ceil(calculatedWidth)));
+      state.setColumnWidth(colId, finalWidth);
+    } else {
+      state.autoFitColumnWidth?.(colId);
+    }
+    const updatedCol = state.document.columns.find((c) => c.id === colId);
+    if (updatedCol && onColumnResize) {
+      onColumnResize(updatedCol.id, updatedCol.width || 130);
+    }
+  }, [state, measureElementContentWidth, onColumnResize]);
+  const handleResizeDblClick = useCallback4((colId, colIndex, e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    autoFitColumn(colId, colIndex);
+  }, [autoFitColumn]);
+  const handleHeaderDblClick = useCallback4((colId, colIndex, e) => {
+    const target = e.currentTarget;
+    if (target) {
+      const rect = target.getBoundingClientRect();
+      if (rect.right - e.clientX <= 12) {
+        e.preventDefault();
+        e.stopPropagation();
+        autoFitColumn(colId, colIndex);
+      }
+    }
+  }, [autoFitColumn]);
+  const isCellSelected = (rIdx, cIdx) => {
+    if (!state.selectedRange) return false;
+    const minR = Math.min(state.selectedRange.startRow, state.selectedRange.endRow);
+    const maxR = Math.max(state.selectedRange.startRow, state.selectedRange.endRow);
+    const minC = Math.min(state.selectedRange.startCol, state.selectedRange.endCol);
+    const maxC = Math.max(state.selectedRange.startCol, state.selectedRange.endCol);
+    return rIdx >= minR && rIdx <= maxR && cIdx >= minC && cIdx <= maxC;
+  };
+  const isActiveCell = (rIdx, cIdx) => {
+    return state.activeCell?.row === rIdx && state.activeCell?.col === cIdx;
+  };
+  const grid = /* @__PURE__ */ jsxs7(
+    "div",
+    {
+      ref: gridRef,
+      className: "flex flex-col h-full w-full overflow-hidden border border-border bg-background select-none outline-none text-foreground font-sans text-xs",
+      tabIndex: 0,
+      onKeyDown: handleKeyDown,
+      role: "grid",
+      "aria-label": "Spreadsheet",
+      children: [
+        /* @__PURE__ */ jsxs7("div", { className: "flex items-center gap-2 border-b border-border bg-muted/20 px-3 py-1.5 text-xs font-mono", children: [
+          /* @__PURE__ */ jsx7("div", { className: "flex h-6 min-w-[3rem] items-center justify-center rounded border border-border bg-background px-1.5 font-semibold text-foreground", children: coordLabel }),
+          /* @__PURE__ */ jsx7("div", { className: "flex items-center text-muted-foreground select-none", children: /* @__PURE__ */ jsx7("span", { className: "italic font-serif font-bold text-sm text-primary", children: "fx" }) }),
+          /* @__PURE__ */ jsx7(
+            "input",
+            {
+              ref: formulaBarRef,
+              type: "text",
+              className: "flex-1 bg-transparent px-2 py-0.5 outline-none font-sans text-xs text-foreground placeholder:text-muted-foreground/60 focus:bg-background focus:ring-1 focus:ring-primary rounded",
+              placeholder: "Enter a value or formula (e.g. =SUM(A1:A5))",
+              "aria-label": "Formula bar",
+              readOnly: formulaBarReadOnly,
+              "data-spill-formula": !state.editingCell && formulaDraft === null && spillFormula ? "true" : void 0,
+              style: !state.editingCell && formulaDraft === null && spillFormula ? { color: "var(--muted-foreground, #94a3b8)" } : void 0,
+              value: state.editingCell ? state.draftValue : formulaDraft ?? (activeRawValue || spillFormula),
+              onFocus: () => {
+                if (!state.editingCell) setFormulaDraft(activeRawValue);
+              },
+              onChange: (e) => {
+                if (state.editingCell) {
+                  state.setDraftValue(e.target.value);
+                } else if (state.activeCell) {
+                  setFormulaDraft(e.target.value);
+                }
+              },
+              onBlur: () => commitFormulaBar(),
+              onKeyDown: (e) => {
+                e.stopPropagation();
+                if (e.key === "Enter") {
+                  e.preventDefault();
+                  commitFormulaBar();
+                } else if (e.key === "Escape") {
+                  e.preventDefault();
+                  setFormulaDraft(null);
+                  if (state.editingCell) state.cancelEditing();
+                }
+              }
+            }
+          ),
+          !formulaBarReadOnly && /* @__PURE__ */ jsx7(
+            FormulaHints,
+            {
+              inputRef: formulaBarRef,
+              value: state.editingCell ? state.draftValue : formulaDraft ?? activeRawValue,
+              onAccept: (next) => state.editingCell ? state.setDraftValue(next) : setFormulaDraft(next),
+              names: nameSuggestions
+            }
+          )
+        ] }),
+        inputMessage && /* @__PURE__ */ jsxs7("div", { role: "note", "data-validation-input-message": "", className: "border-b border-border bg-muted/30 px-3 py-1 text-[11px] text-muted-foreground", children: [
+          inputMessage.inputTitle && /* @__PURE__ */ jsx7("span", { className: "mr-1 font-semibold text-foreground", children: inputMessage.inputTitle }),
+          inputMessage.inputMessage
+        ] }),
+        /* @__PURE__ */ jsx7("div", { ref: scrollRef, className: "relative flex-1 overflow-auto", onScroll: handleGridScroll, children: /* @__PURE__ */ jsxs7("table", { className: "border-separate border-spacing-0 table-fixed w-max min-w-full [&>*>tr:not([data-spacer])>*]:border-b [&>*>tr>*]:border-border", children: [
+          /* @__PURE__ */ jsx7("thead", { children: /* @__PURE__ */ jsxs7("tr", { className: "h-7 bg-muted sticky top-0 z-20 border-b border-border shadow-xs", children: [
+            /* @__PURE__ */ jsx7("th", { className: "w-12 min-w-[3rem] sticky left-0 z-30 bg-muted border-r border-border text-center text-[10px] text-muted-foreground font-medium", children: "#" }),
+            columnSlots.map((slot) => slot.kind === "space" ? /* @__PURE__ */ jsx7(
+              "th",
+              {
+                "aria-hidden": "true",
+                "data-spacer": "",
+                className: "p-0",
+                style: { width: slot.width, minWidth: slot.width, maxWidth: slot.width, padding: 0 }
+              },
+              slot.key
+            ) : (({ column: col, index: cIdx, frozen, stickyLeft }) => /* @__PURE__ */ jsxs7(
+              "th",
+              {
+                "data-col": cIdx,
+                className: `relative border-r border-border px-2 text-left font-medium text-muted-foreground hover:bg-muted/90 transition-colors group overflow-hidden max-w-0 ${onColumnHeaderClick ? "cursor-pointer" : "cursor-default"}`,
+                style: {
+                  width: col.width || 130,
+                  minWidth: col.width || 130,
+                  maxWidth: col.width || 130,
+                  overflow: "hidden",
+                  ...frozen ? { position: "sticky", left: ROW_HEADER_WIDTH + stickyLeft, zIndex: 25, background: "var(--muted, #f4f4f5)" } : {}
+                },
+                onClick: () => onColumnHeaderClick?.(col),
+                onDoubleClick: (e) => handleHeaderDblClick(col.id, cIdx, e),
+                children: [
+                  /* @__PURE__ */ jsxs7("div", { className: "flex items-center justify-between gap-1 min-w-0 overflow-hidden truncate", children: [
+                    /* @__PURE__ */ jsx7("span", { className: "truncate font-semibold text-foreground text-xs min-w-0", children: col.title }),
+                    filteredColIds.has(col.id) && /* @__PURE__ */ jsx7("span", { className: "text-[10px] text-primary shrink-0", title: "Filtered", "data-filtered": "true", children: "\u23F7" }),
+                    /* @__PURE__ */ jsxs7("span", { className: "text-[10px] text-muted-foreground/70 font-mono font-normal shrink-0", children: [
+                      "(",
+                      col.key,
+                      ")"
+                    ] })
+                  ] }),
+                  /* @__PURE__ */ jsx7(
+                    "div",
+                    {
+                      className: "col-resize-handle",
+                      style: { position: "absolute", top: 0, bottom: 0, width: 12, right: -6, cursor: "col-resize", zIndex: 20, display: "flex", justifyContent: "center", touchAction: "none" },
+                      onMouseEnter: () => setHoveredColId(col.id),
+                      onMouseLeave: () => setHoveredColId((cur) => cur === col.id ? null : cur),
+                      onMouseDown: (e) => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                        setResizingColId(col.id);
+                        setResizeStartX(e.clientX);
+                        setResizeStartWidth(col.width || 130);
+                      },
+                      onDoubleClick: (e) => handleResizeDblClick(col.id, cIdx, e),
+                      role: "separator",
+                      "aria-orientation": "vertical",
+                      children: /* @__PURE__ */ jsx7(
+                        "div",
+                        {
+                          className: "col-resize-handle-line",
+                          style: {
+                            width: 2,
+                            height: "100%",
+                            pointerEvents: "none",
+                            transition: "background-color 150ms ease",
+                            backgroundColor: resizingColId === col.id ? "var(--primary, #6366f1)" : hoveredColId === col.id ? "color-mix(in srgb, var(--primary, #6366f1) 75%, transparent)" : "transparent"
+                          }
+                        }
+                      )
+                    }
+                  )
+                ]
+              },
+              col.id
+            ))(slot.viewCol)),
+            onAddColumnClick && /* @__PURE__ */ jsx7(
+              "th",
+              {
+                className: "w-10 min-w-[2.5rem] px-1 text-center bg-muted/40 hover:bg-muted cursor-pointer transition-colors",
+                onClick: onAddColumnClick,
+                title: "Add Column",
+                children: /* @__PURE__ */ jsx7("span", { className: "text-xs font-bold text-muted-foreground", children: "+" })
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ jsx7("tbody", { children: rowSlots.map((rowSlot) => {
+            if (rowSlot.kind === "space") {
+              return /* @__PURE__ */ jsx7("tr", { "aria-hidden": "true", "data-spacer": "", style: { height: rowSlot.height }, children: /* @__PURE__ */ jsx7("td", { colSpan: columnSlots.length + 2, style: { padding: 0, border: 0 } }) }, rowSlot.key);
+            }
+            const viewRow = rowSlot.viewRow;
+            if (viewRow.kind === "group") {
+              return /* @__PURE__ */ jsx7(
+                SpreadsheetGroupRow,
+                {
+                  group: viewRow.group,
+                  columns: renderedColumns,
+                  labelColumns: view.columns,
+                  leadingColumns: viewWindow.virtual ? viewWindow.frozenColumns : void 0,
+                  leftSpace: viewWindow.leftSpace,
+                  rightSpace: viewWindow.rightSpace,
+                  groupColId: state.document.table?.grouping?.colId ?? "",
+                  onToggle: state.toggleGroupCollapsed,
+                  trailingCell: !!onAddColumnClick
+                },
+                `group:${viewRow.group.key}`
+              );
+            }
+            const displayRowIndex = viewRow.index;
+            const selection = state.selectedRange ? normalizeRange2(state.selectedRange) : null;
+            return /* @__PURE__ */ jsxs7(
+              "tr",
+              {
+                "data-row": displayRowIndex,
+                className: `border-b border-border hover:bg-muted/10 transition-colors ${viewRow.section !== "body" ? "bg-muted/30 font-semibold" : ""}`,
+                style: { height: viewRow.row.height || 32 },
+                children: [
+                  /* @__PURE__ */ jsx7(
+                    "td",
+                    {
+                      className: "w-12 min-w-[3rem] sticky left-0 z-10 bg-muted border-r border-border text-center text-[10px] text-muted-foreground font-mono select-none",
+                      style: viewRow.frozen ? { top: COLUMN_HEADER_HEIGHT + viewRow.stickyTop, zIndex: 15 } : void 0,
+                      children: displayRowIndex + 1
+                    }
+                  ),
+                  columnSlots.map((slot) => {
+                    if (slot.kind === "space") return /* @__PURE__ */ jsx7("td", { "aria-hidden": "true", "data-spacer": "", style: { padding: 0 } }, slot.key);
+                    const viewCol = slot.viewCol;
+                    const span = view.getCellSpan(displayRowIndex, viewCol.index);
+                    if (!span) return null;
+                    const rIdx = span.source.row;
+                    const cIdx = span.source.col;
+                    const row = state.document.rows[rIdx];
+                    const col = state.document.columns[cIdx];
+                    const cell = state.getCell(row.id, col.id);
+                    const selected = isCellSelected(rIdx, cIdx);
+                    const active = isActiveCell(rIdx, cIdx);
+                    const isEditing = state.editingCell?.row === rIdx && state.editingCell?.col === cIdx;
+                    const conditional = overlay.get(rIdx, cIdx);
+                    const conditionalCss = getConditionalFormatCss2(conditional);
+                    const circled = state.controller.isInvalidDataCircled(rIdx, cIdx);
+                    const showListArrow = active && !isEditing && !!activeListValues;
+                    const inFillPreview = !!fillTarget && !selected && rangeContains(fillTarget, displayRowIndex, viewCol.index);
+                    const showFillHandle = !readOnly && !isEditing && !!selection && (span.merge ? rangeContains(span.merge, selection.endRow, selection.endCol) : selection.endRow === rIdx && selection.endCol === cIdx);
+                    return /* @__PURE__ */ jsxs7(
+                      "td",
+                      {
+                        "data-row": rIdx,
+                        "data-col": cIdx,
+                        rowSpan: span.rowSpan,
+                        colSpan: span.colSpan,
+                        className: `relative border-r border-border px-2 py-1 truncate max-w-0 text-foreground transition-colors ${selected ? "bg-primary/10" : ""} ${active ? "ring-2 ring-primary ring-inset z-10" : ""} ${viewCol.header ? "font-semibold" : ""}`,
+                        style: {
+                          maxWidth: 0,
+                          overflow: "hidden",
+                          ...frozenCellStyle(viewRow, viewCol),
+                          ...conditionalCss,
+                          // Keep the selection tint visible over a conditional fill.
+                          ...conditionalCss.background && selected ? { boxShadow: "inset 0 0 0 9999px color-mix(in srgb, var(--primary, #6366f1) 12%, transparent)" } : {},
+                          ...inFillPreview ? { outline: "1px dashed var(--primary, #6366f1)", outlineOffset: -1 } : {}
+                        },
+                        "data-cf-fill": conditional?.fill,
+                        onClick: (e) => handleCellClick(rIdx, cIdx, e),
+                        onDoubleClick: () => handleCellDblClick(rIdx, cIdx),
+                        onContextMenu: (e) => handleCellContextMenu(rIdx, cIdx, e),
+                        onMouseOver: () => extendFill(displayRowIndex, viewCol.index),
+                        children: [
+                          isEditing ? /* @__PURE__ */ jsxs7(Fragment2, { children: [
+                            /* @__PURE__ */ jsx7(
+                              "input",
+                              {
+                                ref: cellInputRef,
+                                type: "text",
+                                className: "absolute inset-0 w-full h-full px-2 py-1 bg-background text-foreground outline-none font-sans text-xs border-2 border-primary z-20",
+                                value: state.draftValue,
+                                onChange: (e) => state.setDraftValue(e.target.value),
+                                onBlur: () => state.commitEditing(),
+                                onFocus: (e) => {
+                                  const end = e.currentTarget.value.length;
+                                  e.currentTarget.setSelectionRange(end, end);
+                                },
+                                autoFocus: true
+                              }
+                            ),
+                            /* @__PURE__ */ jsx7(FormulaHints, { inputRef: cellInputRef, value: state.draftValue, onAccept: state.setDraftValue, names: nameSuggestions })
+                          ] }) : customCellRenderer ? customCellRenderer({ row, col, cell }) : /* @__PURE__ */ jsx7(CellText, { cell, conditional }),
+                          circled && /* @__PURE__ */ jsx7(
+                            "span",
+                            {
+                              className: "spreadsheet-invalid-circle",
+                              "aria-label": "Invalid value",
+                              style: { position: "absolute", inset: "1px 2px", border: "2px solid #e11d48", borderRadius: "50%", pointerEvents: "none", zIndex: 6 }
+                            }
+                          ),
+                          showListArrow && /* @__PURE__ */ jsx7(
+                            "button",
+                            {
+                              type: "button",
+                              className: "spreadsheet-list-arrow",
+                              "aria-label": "Show allowed values",
+                              "aria-haspopup": "listbox",
+                              tabIndex: -1,
+                              style: { position: "absolute", right: 1, top: 1, bottom: 1, width: 16, zIndex: 24, fontSize: 10, lineHeight: 1, background: "var(--muted, #f4f4f5)", border: "1px solid var(--border, #e4e4e7)", borderRadius: 2, cursor: "pointer", padding: 0 },
+                              onMouseDown: (e) => e.stopPropagation(),
+                              onClick: (e) => {
+                                e.stopPropagation();
+                                if (listMenu) setListMenu(null);
+                                else openListMenu(rIdx, cIdx, e.currentTarget.parentElement);
+                              },
+                              children: "\u25BE"
+                            }
+                          ),
+                          activeSpill && rangeContains(activeSpill.range, rIdx, cIdx) && /* @__PURE__ */ jsx7("span", { "aria-hidden": "true", className: "spreadsheet-spill-border", style: spillBorderStyle(activeSpill.range, rIdx, cIdx) }),
+                          showFillHandle && /* @__PURE__ */ jsx7(
+                            "div",
+                            {
+                              className: "spreadsheet-fill-handle",
+                              "aria-label": "Fill handle",
+                              onMouseDown: startFill,
+                              onClick: (e) => e.stopPropagation(),
+                              style: { position: "absolute", right: 0, bottom: 0, width: 7, height: 7, background: "var(--primary, #6366f1)", cursor: "crosshair", zIndex: 25 }
+                            }
+                          )
+                        ]
+                      },
+                      viewCol.column.id
+                    );
+                  }),
+                  onAddColumnClick && /* @__PURE__ */ jsx7("td", { className: "w-10 min-w-[2.5rem] bg-muted/10 border-r border-border" })
+                ]
+              },
+              viewRow.row.id
+            );
+          }) })
+        ] }) }),
+        menu && /* @__PURE__ */ jsx7(
+          SpreadsheetContextMenu,
+          {
+            items: menu.items,
+            x: menu.x,
+            y: menu.y,
+            onClose: () => {
+              setMenu(null);
+              gridRef.current?.focus();
+            },
+            onOpenPanel: setPanel
+          }
+        ),
+        panel === "conditionalFormatting" && /* @__PURE__ */ jsx7(SpreadsheetConditionalFormatPanel, { state, onClose: () => setPanel(null) }),
+        panel === "dataValidation" && /* @__PURE__ */ jsx7(SpreadsheetDataValidationPanel, { state, onClose: () => setPanel(null) }),
+        listMenu && /* @__PURE__ */ jsxs7(
+          "div",
+          {
+            role: "listbox",
+            "aria-label": "Allowed values",
+            className: "fixed z-50 max-h-60 min-w-[8rem] overflow-y-auto rounded-md border border-border bg-popover py-1 text-xs text-popover-foreground shadow-lg",
+            style: { left: listMenu.x, top: listMenu.y, background: "var(--popover, var(--background, #fff))" },
+            onKeyDown: (e) => {
+              e.stopPropagation();
+              if (e.key === "Escape") {
+                setListMenu(null);
+                gridRef.current?.focus();
+              }
+            },
+            children: [
+              listMenu.values.length === 0 && /* @__PURE__ */ jsx7("div", { className: "px-3 py-1 text-muted-foreground", children: "No values" }),
+              listMenu.values.map((value, i) => /* @__PURE__ */ jsx7(
+                "button",
+                {
+                  type: "button",
+                  role: "option",
+                  "aria-selected": false,
+                  className: "block w-full px-3 py-1 text-left hover:bg-muted",
+                  onClick: () => chooseListValue(value),
+                  children: value
+                },
+                `${i}:${value}`
+              ))
+            ]
+          }
+        ),
+        state.validationPrompt && /* @__PURE__ */ jsx7(SpreadsheetValidationDialog, { prompt: state.validationPrompt, onResolve: resolveValidation }),
+        /* @__PURE__ */ jsx7("style", { children: `
+        .col-resize-handle:hover .col-resize-handle-line {
+          background-color: var(--primary, #6366f1);
+          opacity: 0.75;
+        }
+        .col-resize-handle.active .col-resize-handle-line {
+          background-color: var(--primary, #6366f1);
+          opacity: 1;
+        }
+        table.table-fixed th {
+          overflow: hidden;
+        }
+        table.table-fixed td {
+          max-width: 0;
+          overflow: hidden;
+        }
+      ` })
+      ]
+    }
+  );
+  if (!showSheetTabs) return grid;
+  return /* @__PURE__ */ jsxs7("div", { className: "flex h-full w-full flex-col", children: [
+    /* @__PURE__ */ jsx7("div", { className: "min-h-0 flex-1", children: grid }),
+    /* @__PURE__ */ jsx7(SheetTabs, { state, readOnly })
+  ] });
+};
+
+// src/spreadsheet/NameManager.tsx
+import { useMemo as useMemo6, useState as useState9 } from "react";
+import { getNameManagerRows, parseFormula } from "@pixerate/editor/spreadsheet";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var EMPTY_DRAFT = { original: null, name: "", refersTo: "=", scope: "", comment: "" };
+var NameManager = ({ state, readOnly = false, onClose, className = "" }) => {
+  const { controller, sheets } = state;
+  const rows = useMemo6(
+    () => getNameManagerRows(controller),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [controller, state.document, state.names]
+  );
+  const [draft, setDraft] = useState9(EMPTY_DRAFT);
+  const [error, setError] = useState9(null);
+  const edit = (row) => {
+    setError(null);
+    setDraft({
+      original: { name: row.name, sheetId: row.sheetId },
+      name: row.name,
+      refersTo: row.refersTo,
+      scope: row.sheetId ?? "",
+      comment: row.comment ?? ""
+    });
+  };
+  const save = (e) => {
+    e.preventDefault();
+    const scope = draft.scope ? { sheet: draft.scope } : {};
+    try {
+      const invalid = controller.validateDefinedName(draft.name.trim());
+      if (invalid) throw new Error(invalid);
+      try {
+        parseFormula(draft.refersTo.trim().startsWith("=") ? draft.refersTo.trim() : `=${draft.refersTo.trim()}`);
+      } catch (err) {
+        throw new Error(`There's a problem with this formula: ${err?.message ?? draft.refersTo}`);
+      }
+      const original = draft.original;
+      if (original) {
+        const originalScope = original.sheetId ? { sheet: original.sheetId } : {};
+        if ((original.sheetId ?? "") !== draft.scope) {
+          state.deleteName(original.name, originalScope);
+        } else if (original.name !== draft.name) {
+          state.renameName(original.name, draft.name.trim(), originalScope);
+        }
+      }
+      state.defineName(draft.name.trim(), draft.refersTo, { ...scope, comment: draft.comment || void 0 });
+      setDraft(EMPTY_DRAFT);
+      setError(null);
+    } catch (err) {
+      setError(err?.message ?? String(err));
+    }
+  };
+  return /* @__PURE__ */ jsxs8("section", { "aria-label": "Name Manager", className: `flex flex-col gap-2 text-xs ${className}`, "data-name-manager": "", children: [
+    /* @__PURE__ */ jsxs8("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsx8("h3", { className: "m-0 text-sm font-semibold", children: "Name Manager" }),
+      onClose && /* @__PURE__ */ jsx8("button", { type: "button", "aria-label": "Close Name Manager", className: "rounded px-2 hover:bg-muted", onClick: onClose, children: "\xD7" })
+    ] }),
+    /* @__PURE__ */ jsxs8("table", { className: "w-full border-collapse", children: [
+      /* @__PURE__ */ jsx8("thead", { children: /* @__PURE__ */ jsxs8("tr", { className: "text-left text-muted-foreground", children: [
+        /* @__PURE__ */ jsx8("th", { className: "px-1 font-medium", children: "Name" }),
+        /* @__PURE__ */ jsx8("th", { className: "px-1 font-medium", children: "Value" }),
+        /* @__PURE__ */ jsx8("th", { className: "px-1 font-medium", children: "Refers to" }),
+        /* @__PURE__ */ jsx8("th", { className: "px-1 font-medium", children: "Scope" }),
+        !readOnly && /* @__PURE__ */ jsx8("th", { className: "px-1" })
+      ] }) }),
+      /* @__PURE__ */ jsxs8("tbody", { children: [
+        rows.length === 0 && /* @__PURE__ */ jsx8("tr", { children: /* @__PURE__ */ jsx8("td", { colSpan: 5, className: "px-1 py-2 text-muted-foreground", children: "No names yet." }) }),
+        rows.map((row) => /* @__PURE__ */ jsxs8("tr", { "data-name": row.name, className: "border-t border-border", title: row.comment, children: [
+          /* @__PURE__ */ jsx8("td", { className: "px-1 py-0.5 font-mono font-semibold", children: row.name }),
+          /* @__PURE__ */ jsx8("td", { className: "px-1 py-0.5", children: row.value }),
+          /* @__PURE__ */ jsx8("td", { className: "px-1 py-0.5 font-mono", children: row.refersTo }),
+          /* @__PURE__ */ jsx8("td", { className: "px-1 py-0.5", children: row.scopeLabel }),
+          !readOnly && /* @__PURE__ */ jsxs8("td", { className: "whitespace-nowrap px-1 py-0.5 text-right", children: [
+            /* @__PURE__ */ jsx8("button", { type: "button", "aria-label": `Edit ${row.name}`, className: "rounded px-1 hover:bg-muted", onClick: () => edit(row), children: "Edit" }),
+            /* @__PURE__ */ jsx8(
+              "button",
+              {
+                type: "button",
+                "aria-label": `Delete ${row.name}`,
+                className: "rounded px-1 text-destructive hover:bg-muted",
+                onClick: () => {
+                  state.deleteName(row.name, row.sheetId ? { sheet: row.sheetId } : {});
+                  if (draft.original?.name === row.name && (draft.original.sheetId ?? "") === (row.sheetId ?? "")) setDraft(EMPTY_DRAFT);
+                },
+                children: "Delete"
+              }
+            )
+          ] })
+        ] }, `${row.sheetId ?? ""}!${row.name}`))
+      ] })
+    ] }),
+    !readOnly && /* @__PURE__ */ jsxs8("form", { className: "grid grid-cols-[auto_1fr] items-center gap-x-2 gap-y-1", onSubmit: save, "aria-label": draft.original ? `Edit name ${draft.original.name}` : "New name", children: [
+      /* @__PURE__ */ jsx8("label", { htmlFor: "pixerate-name-manager-name", children: "Name" }),
+      /* @__PURE__ */ jsx8(
+        "input",
+        {
+          id: "pixerate-name-manager-name",
+          className: "rounded border border-border bg-background px-1 py-0.5",
+          value: draft.name,
+          onChange: (e) => setDraft({ ...draft, name: e.target.value })
+        }
+      ),
+      /* @__PURE__ */ jsx8("label", { htmlFor: "pixerate-name-manager-refers", children: "Refers to" }),
+      /* @__PURE__ */ jsx8(
+        "input",
+        {
+          id: "pixerate-name-manager-refers",
+          className: "rounded border border-border bg-background px-1 py-0.5 font-mono",
+          value: draft.refersTo,
+          onChange: (e) => setDraft({ ...draft, refersTo: e.target.value })
+        }
+      ),
+      /* @__PURE__ */ jsx8("label", { htmlFor: "pixerate-name-manager-scope", children: "Scope" }),
+      /* @__PURE__ */ jsxs8(
+        "select",
+        {
+          id: "pixerate-name-manager-scope",
+          className: "rounded border border-border bg-background px-1 py-0.5",
+          value: draft.scope,
+          onChange: (e) => setDraft({ ...draft, scope: e.target.value }),
+          children: [
+            /* @__PURE__ */ jsx8("option", { value: "", children: "Workbook" }),
+            sheets.map((sheet) => /* @__PURE__ */ jsx8("option", { value: sheet.id, children: sheet.name }, sheet.id))
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx8("label", { htmlFor: "pixerate-name-manager-comment", children: "Comment" }),
+      /* @__PURE__ */ jsx8(
+        "input",
+        {
+          id: "pixerate-name-manager-comment",
+          className: "rounded border border-border bg-background px-1 py-0.5",
+          value: draft.comment,
+          onChange: (e) => setDraft({ ...draft, comment: e.target.value })
+        }
+      ),
+      /* @__PURE__ */ jsxs8("div", { className: "col-span-2 flex gap-2", children: [
+        /* @__PURE__ */ jsx8("button", { type: "submit", className: "rounded bg-primary px-2 py-0.5 text-primary-foreground", children: draft.original ? "Save" : "Add name" }),
+        draft.original && /* @__PURE__ */ jsx8(
+          "button",
+          {
+            type: "button",
+            className: "rounded px-2 py-0.5 hover:bg-muted",
+            onClick: () => {
+              setDraft(EMPTY_DRAFT);
+              setError(null);
+            },
+            children: "Cancel"
+          }
+        )
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsx8("div", { role: "alert", className: "text-destructive", children: error })
+  ] });
+};
+
+export {
+  useSpreadsheetEditor,
+  SpreadsheetContextMenu,
+  SpreadsheetGroupRow,
+  useSpreadsheetClipboard,
+  useFillHandle,
+  SpreadsheetValidationDialog,
+  SpreadsheetConditionalFormatPanel,
+  SpreadsheetDataValidationPanel,
+  useSpreadsheetViewport,
+  FormulaHints,
+  SheetTabs,
+  SpreadsheetEditor,
+  NameManager
+};
+//# sourceMappingURL=chunk-34HEZX7J.js.map