@pixerate/editor 0.18.0 → 0.20.0

package/dist/chunk-GVW4P7BG.js

@@ -0,0 +1,2706 @@
+import {
+  FormulaEvaluator,
+  WHOLE_COLUMN_END_ROW,
+  colNameToIndex,
+  getFormulaArgumentSpecIndex,
+  getFormulaFunction,
+  getFormulaSignature,
+  getFormulaSignatureParts,
+  indexToColName,
+  parseFormula,
+  searchFormulaFunctions,
+  tokenizeFormula
+} from "./chunk-A7DKIA72.js";
+
+// src/spreadsheet/formula/dependency-graph.ts
+var columnDependencyKey = (col) => `${col.toUpperCase()}:`;
+function extractCellDependencies(node) {
+  const deps = [];
+  const visit = (curr) => {
+    if (curr.type === "CellRef") {
+      deps.push({ col: curr.col, row: curr.row });
+    } else if (curr.type === "Range" && curr.endRow >= WHOLE_COLUMN_END_ROW) {
+      const startC = colNameToIndex(curr.startCol);
+      const endC = colNameToIndex(curr.endCol);
+      for (let c = Math.min(startC, endC); c <= Math.max(startC, endC); c++) {
+        deps.push({ col: indexToColName(c), row: 0 });
+      }
+    } else if (curr.type === "Range") {
+      const startC = colNameToIndex(curr.startCol);
+      const endC = colNameToIndex(curr.endCol);
+      const minC = Math.min(startC, endC);
+      const maxC = Math.max(startC, endC);
+      const minR = Math.min(curr.startRow, curr.endRow);
+      const maxR = Math.max(curr.startRow, curr.endRow);
+      for (let c = minC; c <= maxC; c++) {
+        for (let r = minR; r <= maxR; r++) {
+          deps.push({ col: indexToColName(c), row: r });
+        }
+      }
+    } else if (curr.type === "BinaryOp") {
+      visit(curr.left);
+      visit(curr.right);
+    } else if (curr.type === "UnaryOp") {
+      visit(curr.argument);
+    } else if (curr.type === "FunctionCall") {
+      curr.args.forEach(visit);
+    }
+  };
+  visit(node);
+  return deps;
+}
+var DependencyGraph = class {
+  // Map of cellKey (e.g. "B2") -> Set of cellKeys that this cell depends ON
+  dependencies = /* @__PURE__ */ new Map();
+  // Map of cellKey (e.g. "A1") -> Set of cellKeys that depend ON this cell (dependents)
+  dependents = /* @__PURE__ */ new Map();
+  setCellFormula(cellKey, formulaStr) {
+    const key = cellKey.toUpperCase();
+    const oldDeps = this.dependencies.get(key) || /* @__PURE__ */ new Set();
+    for (const dep of oldDeps) {
+      this.dependents.get(dep)?.delete(key);
+    }
+    this.dependencies.delete(key);
+    if (!formulaStr || !formulaStr.startsWith("=")) {
+      return;
+    }
+    try {
+      const ast = parseFormula(formulaStr);
+      const deps = extractCellDependencies(ast);
+      const newDeps = /* @__PURE__ */ new Set();
+      for (const d of deps) {
+        const depKey = d.row === 0 ? columnDependencyKey(d.col) : `${d.col}${d.row}`.toUpperCase();
+        newDeps.add(depKey);
+        if (!this.dependents.has(depKey)) {
+          this.dependents.set(depKey, /* @__PURE__ */ new Set());
+        }
+        this.dependents.get(depKey).add(key);
+      }
+      this.dependencies.set(key, newDeps);
+    } catch {
+    }
+  }
+  /** Removes every registered formula and dependency. */
+  clear() {
+    this.dependencies.clear();
+    this.dependents.clear();
+  }
+  getDependencies(cellKey) {
+    return Array.from(this.dependencies.get(cellKey.toUpperCase()) || []);
+  }
+  getDependents(cellKey) {
+    return Array.from(this.dependents.get(cellKey.toUpperCase()) || []);
+  }
+  /**
+   * Detects if there is a cycle containing cellKey.
+   */
+  hasCycle(cellKey) {
+    const key = cellKey.toUpperCase();
+    const visited = /* @__PURE__ */ new Set();
+    const recStack = /* @__PURE__ */ new Set();
+    const dfs = (node) => {
+      visited.add(node);
+      recStack.add(node);
+      const deps = this.dependencies.get(node) || /* @__PURE__ */ new Set();
+      for (const neighbor of deps) {
+        if (!visited.has(neighbor)) {
+          if (dfs(neighbor)) return true;
+        } else if (recStack.has(neighbor)) {
+          return true;
+        }
+      }
+      recStack.delete(node);
+      return false;
+    };
+    return dfs(key);
+  }
+  /**
+   * Returns cells affected by updating cellKey in topological order.
+   */
+  getEvaluationOrder(startCellKey) {
+    const start = startCellKey.toUpperCase();
+    const visited = /* @__PURE__ */ new Set();
+    const recStack = /* @__PURE__ */ new Set();
+    const order = [];
+    let cycleDetected = false;
+    const affected = /* @__PURE__ */ new Set();
+    const collectAffected = (node) => {
+      affected.add(node);
+      const directDependents = this.dependents.get(node) || /* @__PURE__ */ new Set();
+      for (const dep of directDependents) {
+        if (!affected.has(dep)) {
+          collectAffected(dep);
+        }
+      }
+    };
+    collectAffected(start);
+    const visit = (node) => {
+      if (recStack.has(node)) {
+        cycleDetected = true;
+        return;
+      }
+      if (visited.has(node)) return;
+      recStack.add(node);
+      visited.add(node);
+      const deps = this.dependencies.get(node) || /* @__PURE__ */ new Set();
+      for (const neighbor of deps) {
+        if (affected.has(neighbor)) {
+          visit(neighbor);
+        }
+      }
+      recStack.delete(node);
+      order.push(node);
+    };
+    for (const node of affected) {
+      if (!visited.has(node)) {
+        visit(node);
+      }
+    }
+    return { order, hasCycle: cycleDetected };
+  }
+  /**
+   * Plans a recalculation over `cellKeys` (and, with `includeDependents`, every
+   * cell that transitively depends on them). Returns the keys in evaluation
+   * order (dependencies first) and the set of keys that are part of a cycle,
+   * which must be marked `#CYCLE!` instead of evaluated. Every member of a
+   * cycle is reported, not just the cell that closed it.
+   */
+  getEvaluationPlan(cellKeys, options = {}) {
+    const nodes = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const key of cellKeys) {
+      const upper = key.toUpperCase();
+      if (!nodes.has(upper)) {
+        nodes.add(upper);
+        queue.push(upper);
+      }
+    }
+    if (options.includeDependents) {
+      while (queue.length > 0) {
+        const node = queue.pop();
+        const direct = [
+          ...this.dependents.get(node) ?? [],
+          ...this.dependents.get(columnDependencyKey(node.replace(/\d+$/, ""))) ?? []
+        ];
+        for (const dep of direct) {
+          if (!nodes.has(dep)) {
+            nodes.add(dep);
+            queue.push(dep);
+          }
+        }
+      }
+    }
+    const neighbors = (node) => {
+      const result = [];
+      for (const dep of this.dependencies.get(node) ?? []) {
+        if (dep.endsWith(":")) {
+          const col = dep.slice(0, -1);
+          for (const candidate of nodes) {
+            if (candidate.replace(/\d+$/, "") === col) result.push(candidate);
+          }
+        } else if (nodes.has(dep)) {
+          result.push(dep);
+        }
+      }
+      return result;
+    };
+    const order = [];
+    const cyclic = /* @__PURE__ */ new Set();
+    const index = /* @__PURE__ */ new Map();
+    const low = /* @__PURE__ */ new Map();
+    const stack = [];
+    const onStack = /* @__PURE__ */ new Set();
+    let counter = 0;
+    for (const root of nodes) {
+      if (index.has(root)) continue;
+      const work = [];
+      const enter = (node) => {
+        index.set(node, counter);
+        low.set(node, counter);
+        counter++;
+        stack.push(node);
+        onStack.add(node);
+        work.push({ node, edges: neighbors(node), next: 0 });
+      };
+      enter(root);
+      while (work.length > 0) {
+        const frame = work[work.length - 1];
+        if (frame.next < frame.edges.length) {
+          const target = frame.edges[frame.next++];
+          if (!index.has(target)) {
+            enter(target);
+          } else if (onStack.has(target)) {
+            low.set(frame.node, Math.min(low.get(frame.node), index.get(target)));
+          }
+          continue;
+        }
+        work.pop();
+        if (work.length > 0) {
+          const parent = work[work.length - 1].node;
+          low.set(parent, Math.min(low.get(parent), low.get(frame.node)));
+        }
+        if (low.get(frame.node) === index.get(frame.node)) {
+          const component = [];
+          let member;
+          do {
+            member = stack.pop();
+            onStack.delete(member);
+            component.push(member);
+          } while (member !== frame.node);
+          const isCycle = component.length > 1 || frame.edges.includes(frame.node);
+          for (const key of component) {
+            order.push(key);
+            if (isCycle) cyclic.add(key);
+          }
+        }
+      }
+    }
+    return { order, cyclic };
+  }
+};
+
+// src/spreadsheet/formula/references.ts
+var CELL_PART = /^(\$?)([A-Za-z]+)(\$?)(\d+)$/;
+var COLUMN_PART = /^(\$?)([A-Za-z]+)$/;
+var REF_CHAR = /[A-Za-z0-9_$.:]/;
+function parsePart(text) {
+  const cell = CELL_PART.exec(text);
+  if (cell) {
+    return {
+      colAbs: cell[1],
+      col: colNameToIndex(cell[2]),
+      rowAbs: cell[3],
+      row: parseInt(cell[4], 10) - 1
+    };
+  }
+  const column = COLUMN_PART.exec(text);
+  if (column) {
+    return { colAbs: column[1], col: colNameToIndex(column[2]), rowAbs: "", row: null };
+  }
+  return null;
+}
+function formatPart(part) {
+  const col = `${part.colAbs}${indexToColName(part.col)}`;
+  return part.row === null ? col : `${col}${part.rowAbs}${part.row + 1}`;
+}
+function shiftCoordinate(value, change) {
+  if (change.type === "insert") {
+    return value >= change.index ? value + 1 : value;
+  }
+  if (value === change.index) return null;
+  return value > change.index ? value - 1 : value;
+}
+function shiftSpan(lo, hi, change) {
+  if (change.type === "insert") {
+    return [lo >= change.index ? lo + 1 : lo, hi >= change.index ? hi + 1 : hi];
+  }
+  if (lo === change.index && hi === change.index) return null;
+  return [lo > change.index ? lo - 1 : lo, hi >= change.index ? hi - 1 : hi];
+}
+function rewriteReference(text, change) {
+  const [startText, endText] = text.split(":");
+  const start = parsePart(startText);
+  if (!start) return text;
+  const key = change.axis === "row" ? "row" : "col";
+  if (endText === void 0) {
+    if (start[key] === null) return text;
+    const shifted = shiftCoordinate(start[key], change);
+    if (shifted === null) return "#REF!";
+    return formatPart({ ...start, [key]: shifted });
+  }
+  const end = parsePart(endText);
+  if (!end) return text;
+  if (start[key] === null || end[key] === null) return text;
+  const startValue = start[key];
+  const endValue = end[key];
+  const span = shiftSpan(Math.min(startValue, endValue), Math.max(startValue, endValue), change);
+  if (span === null) return "#REF!";
+  const [lo, hi] = span;
+  const newStart = { ...start, [key]: startValue <= endValue ? lo : hi };
+  const newEnd = { ...end, [key]: startValue <= endValue ? hi : lo };
+  return `${formatPart(newStart)}:${formatPart(newEnd)}`;
+}
+function shiftFormulaReferences(formula, change) {
+  return mapFormulaReferences(formula, (text) => rewriteReference(text, change));
+}
+function mapFormulaReferences(formula, rewrite) {
+  if (!formula.startsWith("=")) return formula;
+  let tokens;
+  try {
+    tokens = tokenizeFormula(formula);
+  } catch {
+    return formula;
+  }
+  let result = "";
+  let cursor = 0;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.type !== "CELL_REF" && token.type !== "RANGE") continue;
+    if (tokens[i + 1]?.type === "LPAREN") continue;
+    let end = token.position;
+    while (end < formula.length && REF_CHAR.test(formula[end])) end++;
+    const original = formula.slice(token.position, end);
+    result += formula.slice(cursor, token.position) + rewrite(original);
+    cursor = end;
+  }
+  return result + formula.slice(cursor);
+}
+function offsetFormulaReferences(formula, rowOffset, colOffset) {
+  if (rowOffset === 0 && colOffset === 0) return formula;
+  return mapFormulaReferences(formula, (text) => {
+    const parts = text.split(":").map(parsePart);
+    if (parts.some((p) => p === null)) return text;
+    const moved = [];
+    for (const part of parts) {
+      const col = part.colAbs ? part.col : part.col + colOffset;
+      const row = part.row === null || part.rowAbs ? part.row : part.row + rowOffset;
+      if (col < 0 || row !== null && row < 0) return "#REF!";
+      moved.push({ ...part, col, row });
+    }
+    return moved.map(formatPart).join(":");
+  });
+}
+var MAX_REMAP_RANGE_CELLS = 1e5;
+function remapFormulaReferences(formula, moveCell) {
+  return mapFormulaReferences(formula, (text) => {
+    const parts = text.split(":").map(parsePart);
+    if (parts.some((p) => p === null)) return text;
+    const [start, end] = parts;
+    if (start.row === null || end && end.row === null) return text;
+    if (!end) {
+      const target = moveCell({ row: start.row, col: start.col });
+      return target ? formatPart({ ...start, row: target.row, col: target.col }) : text;
+    }
+    const lo = { row: Math.min(start.row, end.row), col: Math.min(start.col, end.col) };
+    const hi = { row: Math.max(start.row, end.row), col: Math.max(start.col, end.col) };
+    const area = (hi.row - lo.row + 1) * (hi.col - lo.col + 1);
+    if (area > MAX_REMAP_RANGE_CELLS) return text;
+    let minR = Infinity;
+    let maxR = -Infinity;
+    let minC = Infinity;
+    let maxC = -Infinity;
+    let movedAny = false;
+    const targets = /* @__PURE__ */ new Set();
+    for (let r = lo.row; r <= hi.row; r++) {
+      for (let c = lo.col; c <= hi.col; c++) {
+        const moved = moveCell({ row: r, col: c });
+        if (moved) movedAny = true;
+        const t = moved ?? { row: r, col: c };
+        targets.add(`${t.row}:${t.col}`);
+        minR = Math.min(minR, t.row);
+        maxR = Math.max(maxR, t.row);
+        minC = Math.min(minC, t.col);
+        maxC = Math.max(maxC, t.col);
+      }
+    }
+    if (!movedAny || targets.size !== area || (maxR - minR + 1) * (maxC - minC + 1) !== area) {
+      return text;
+    }
+    return `${formatPart({ ...start, row: minR, col: minC })}:${formatPart({ ...end, row: maxR, col: maxC })}`;
+  });
+}
+
+// src/spreadsheet/formula/caret.ts
+var EMPTY = { prefix: null, call: null };
+function getFormulaCaretContext(input, caret = input.length) {
+  const leading = input.length - input.trimStart().length;
+  if (input[leading] !== "=") return EMPTY;
+  const end = Math.max(0, Math.min(caret, input.length));
+  if (end <= leading) return EMPTY;
+  const stack = [];
+  let quote2 = null;
+  let inProperty = false;
+  for (let i = leading + 1; i < end; i++) {
+    const char = input[i];
+    if (quote2) {
+      if (char === "\\") i++;
+      else if (char === quote2) quote2 = null;
+      continue;
+    }
+    if (inProperty) {
+      if (char === "]") inProperty = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote2 = char;
+    } else if (char === "[") {
+      inProperty = true;
+    } else if (char === "(") {
+      const name = /([A-Za-z_][A-Za-z0-9_.]*)\s*$/.exec(input.slice(leading + 1, i));
+      const isFunction = name && !/^\$?[A-Za-z]+\$?\d+$/.test(name[1]) && !/[:$]$/.test(input.slice(0, i - name[0].length));
+      stack.push({ name: isFunction ? name[1].toUpperCase() : null, argIndex: 0, openParen: i });
+    } else if (char === ")") {
+      stack.pop();
+    } else if (char === "," && stack.length > 0) {
+      stack[stack.length - 1].argIndex++;
+    }
+  }
+  if (quote2 || inProperty) {
+    return { prefix: null, call: innermostCall(stack) };
+  }
+  let prefix = null;
+  const before = input.slice(leading + 1, end);
+  const word = /[A-Za-z_][A-Za-z0-9_.]*$/.exec(before);
+  if (word) {
+    const start = leading + 1 + word.index;
+    const preceding = input[start - 1] ?? "";
+    if (!/[:$0-9.]/.test(preceding)) {
+      prefix = { text: word[0], start, end };
+    }
+  }
+  return { prefix, call: innermostCall(stack) };
+}
+function innermostCall(stack) {
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const frame = stack[i];
+    if (frame.name) return { name: frame.name, argIndex: frame.argIndex, openParen: frame.openParen };
+  }
+  return null;
+}
+var toSuggestion = (def) => ({
+  name: def.name,
+  signature: getFormulaSignature(def),
+  description: def.description,
+  category: def.category
+});
+function getFormulaHints(input, caret = input.length, options = {}) {
+  const context = getFormulaCaretContext(input, caret);
+  let suggestions = [];
+  if (context.prefix) {
+    const query = context.prefix.text.toUpperCase();
+    suggestions = searchFormulaFunctions(query, { limit: void 0 }).filter((def) => def.name.startsWith(query)).slice(0, options.limit ?? 8).map(toSuggestion);
+    const followedByParen = input.slice(context.prefix.end).trimStart().startsWith("(");
+    if (followedByParen || suggestions.length === 1 && suggestions[0].name === query) suggestions = [];
+  }
+  let activeCall = null;
+  if (context.call) {
+    const def = getFormulaFunction(context.call.name);
+    if (def) {
+      const specIndex = getFormulaArgumentSpecIndex(def, context.call.argIndex);
+      activeCall = {
+        name: def.name,
+        signature: getFormulaSignature(def),
+        description: def.description,
+        parts: getFormulaSignatureParts(def, context.call.argIndex),
+        argIndex: context.call.argIndex,
+        argument: specIndex >= 0 ? def.args[specIndex] : null
+      };
+    }
+  }
+  return { context, suggestions, activeCall };
+}
+function applyFormulaSuggestion(input, caret, name) {
+  const context = getFormulaCaretContext(input, caret);
+  const start = context.prefix?.start ?? caret;
+  const end = context.prefix?.end ?? caret;
+  const hasParen = input[end] === "(";
+  const insert = hasParen ? name.toUpperCase() : `${name.toUpperCase()}(`;
+  const value = input.slice(0, start) + insert + input.slice(end);
+  return { value, caret: start + insert.length + (hasParen ? 1 : 0) };
+}
+
+// src/spreadsheet/datasource/index.ts
+var DataSourceBinder = class {
+  dataSources = /* @__PURE__ */ new Map();
+  register(dataSource) {
+    this.dataSources.set(dataSource.id, dataSource);
+  }
+  unregister(dataSourceId) {
+    this.dataSources.delete(dataSourceId);
+  }
+  getDataSource(id) {
+    return this.dataSources.get(id);
+  }
+  /**
+   * Generates or reconciles spreadsheet rows from a primary data source.
+   */
+  syncRows(currentRows, dataSourceId) {
+    const ds = this.dataSources.get(dataSourceId);
+    if (!ds) return currentRows;
+    const records = ds.getRecords();
+    const existingRecordRowMap = /* @__PURE__ */ new Map();
+    const freeformRows = [];
+    for (const row of currentRows) {
+      if (row.type === "record" && row.recordId) {
+        existingRecordRowMap.set(row.recordId, row);
+      } else {
+        freeformRows.push(row);
+      }
+    }
+    const nextRows = [];
+    let rowIndex = 0;
+    for (const record of records) {
+      const existing = existingRecordRowMap.get(record.id);
+      nextRows.push({
+        ...existing?.hidden ? { hidden: true } : {},
+        id: existing?.id || `row_${record.id}`,
+        index: rowIndex++,
+        height: existing?.height || 32,
+        recordId: record.id,
+        type: "record"
+      });
+      existingRecordRowMap.delete(record.id);
+    }
+    for (const freeform of freeformRows) {
+      nextRows.push({
+        ...freeform,
+        index: rowIndex++
+      });
+    }
+    return nextRows;
+  }
+  /**
+   * Resolves a record's bound field value.
+   */
+  resolveBoundValue(dataSourceId, recordId, field) {
+    const ds = this.dataSources.get(dataSourceId);
+    if (!ds) return void 0;
+    const records = ds.getRecords();
+    const record = records.find((r) => r.id === recordId);
+    return record ? record[field] : void 0;
+  }
+  /**
+   * Dispatches an update to the underlying data source.
+   */
+  async commitBoundValue(dataSourceId, recordId, field, value) {
+    const ds = this.dataSources.get(dataSourceId);
+    if (!ds) return;
+    await ds.updateRecord(recordId, field, value);
+  }
+};
+
+// src/spreadsheet/table.ts
+function normalizeRange(range) {
+  return {
+    startRow: Math.min(range.startRow, range.endRow),
+    startCol: Math.min(range.startCol, range.endCol),
+    endRow: Math.max(range.startRow, range.endRow),
+    endCol: Math.max(range.startCol, range.endCol)
+  };
+}
+function rangeContains(range, row, col) {
+  const r = normalizeRange(range);
+  return row >= r.startRow && row <= r.endRow && col >= r.startCol && col <= r.endCol;
+}
+function rangesIntersect(a, b) {
+  const x = normalizeRange(a);
+  const y = normalizeRange(b);
+  return x.startRow <= y.endRow && y.startRow <= x.endRow && x.startCol <= y.endCol && y.startCol <= x.endCol;
+}
+function rangeContainsRange(outer, inner) {
+  const o = normalizeRange(outer);
+  const i = normalizeRange(inner);
+  return i.startRow >= o.startRow && i.endRow <= o.endRow && i.startCol >= o.startCol && i.endCol <= o.endCol;
+}
+function isSingleCellRange(range) {
+  const r = normalizeRange(range);
+  return r.startRow === r.endRow && r.startCol === r.endCol;
+}
+var NUMBER_PATTERN = /^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i;
+var ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+function isBlankValue(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function toNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (NUMBER_PATTERN.test(trimmed)) return parseFloat(trimmed);
+  }
+  return null;
+}
+var collator = typeof Intl !== "undefined" ? new Intl.Collator(void 0, { numeric: true, sensitivity: "base" }) : null;
+function compareText(a, b) {
+  return collator ? collator.compare(a, b) : a < b ? -1 : a > b ? 1 : 0;
+}
+function compareCellValues(a, b, direction = "asc") {
+  const aBlank = isBlankValue(a);
+  const bBlank = isBlankValue(b);
+  if (aBlank || bBlank) return aBlank === bBlank ? 0 : aBlank ? 1 : -1;
+  const aNum = toNumber(a);
+  const bNum = toNumber(b);
+  let result;
+  if (aNum !== null && bNum !== null) result = aNum - bNum;
+  else if (aNum !== null) result = -1;
+  else if (bNum !== null) result = 1;
+  else result = compareText(String(a), String(b));
+  if (result === 0) return 0;
+  return direction === "desc" ? -Math.sign(result) : Math.sign(result);
+}
+function compareForFilter(value, operand) {
+  if (isBlankValue(value) || isBlankValue(operand)) return null;
+  const a = toNumber(value);
+  const b = toNumber(operand);
+  if (a !== null && b !== null) return a - b;
+  if (a !== null || b !== null) return null;
+  return compareText(String(value), String(operand));
+}
+function looselyEquals(value, operand) {
+  const a = toNumber(value);
+  const b = toNumber(operand);
+  if (a !== null && b !== null) return a === b;
+  return String(value ?? "").trim().toLowerCase() === String(operand ?? "").trim().toLowerCase();
+}
+function matchesFilterRule(value, rule) {
+  const text = String(value ?? "").toLowerCase();
+  switch (rule.operator) {
+    case "equals":
+      return looselyEquals(value, rule.value);
+    case "notEquals":
+      return !looselyEquals(value, rule.value);
+    case "contains":
+      return text.includes(String(rule.value ?? "").toLowerCase());
+    case "notContains":
+      return !text.includes(String(rule.value ?? "").toLowerCase());
+    case "greaterThan": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c > 0;
+    }
+    case "greaterThanOrEqual": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c >= 0;
+    }
+    case "lessThan": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c < 0;
+    }
+    case "lessThanOrEqual": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c <= 0;
+    }
+    case "between": {
+      const lo = compareForFilter(value, rule.value);
+      const hi = compareForFilter(value, rule.value2);
+      return lo !== null && hi !== null && lo >= 0 && hi <= 0;
+    }
+    case "isBlank":
+      return isBlankValue(value);
+    case "isNotBlank":
+      return !isBlankValue(value);
+    case "oneOf":
+      return (rule.values ?? []).some((candidate) => String(candidate) === String(value ?? ""));
+    default:
+      return true;
+  }
+}
+function aggregateValues(values, aggregate) {
+  if (aggregate === "count") return values.filter((v) => !isBlankValue(v)).length;
+  const numbers = [];
+  for (const v of values) {
+    const n = toNumber(v);
+    if (n !== null) numbers.push(n);
+  }
+  if (numbers.length === 0) return aggregate === "sum" ? 0 : null;
+  switch (aggregate) {
+    case "sum":
+      return roundFloat(numbers.reduce((s, n) => s + n, 0));
+    case "average":
+      return roundFloat(numbers.reduce((s, n) => s + n, 0) / numbers.length);
+    case "min":
+      return numbers.reduce((m, n) => n < m ? n : m, numbers[0]);
+    case "max":
+      return numbers.reduce((m, n) => n > m ? n : m, numbers[0]);
+    default:
+      return null;
+  }
+}
+function roundFloat(value) {
+  return Number.isInteger(value) ? value : parseFloat(value.toPrecision(12));
+}
+var DAY_MS = 864e5;
+var TRAILING_NUMBER = /^(.*?)(\d+)(\D*)$/;
+function classifyFillValue(raw) {
+  if (raw.trim() === "") return { kind: "blank" };
+  const num = toNumber(raw);
+  if (num !== null) return { kind: "number", value: num };
+  const date = ISO_DATE_PATTERN.exec(raw.trim());
+  if (date) {
+    const [year, month, day] = [Number(date[1]), Number(date[2]), Number(date[3])];
+    const time = Date.UTC(year, month - 1, day);
+    const check = new Date(time);
+    if (check.getUTCMonth() === month - 1 && check.getUTCDate() === day) {
+      return { kind: "date", time, year, month, day };
+    }
+  }
+  const textNumber = TRAILING_NUMBER.exec(raw);
+  if (textNumber && textNumber[1] !== "") {
+    return {
+      kind: "textNumber",
+      prefix: textNumber[1],
+      value: parseInt(textNumber[2], 10),
+      width: textNumber[2].length,
+      suffix: textNumber[3]
+    };
+  }
+  return { kind: "text", text: raw };
+}
+var pad = (n, width) => String(Math.abs(n)).padStart(width, "0");
+function formatDate(time) {
+  const d = new Date(time);
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1, 2)}-${pad(d.getUTCDate(), 2)}`;
+}
+function constantStep(values) {
+  const step = values[1] - values[0];
+  for (let i = 2; i < values.length; i++) {
+    if (Math.abs(values[i] - values[i - 1] - step) > 1e-9) return null;
+  }
+  return step;
+}
+function linearTrend(values, x) {
+  const n = values.length;
+  const meanX = (n - 1) / 2;
+  const meanY = values.reduce((s, v) => s + v, 0) / n;
+  let num = 0;
+  let den = 0;
+  values.forEach((v, i) => {
+    num += (i - meanX) * (v - meanY);
+    den += (i - meanX) ** 2;
+  });
+  const slope = den === 0 ? 0 : num / den;
+  return meanY + slope * (x - meanX);
+}
+function fillSeries(source, count) {
+  if (count <= 0) return [];
+  if (source.length === 0) return Array(count).fill("");
+  const repeat = () => Array.from({ length: count }, (_, i) => source[i % source.length]);
+  const parsed = source.map(classifyFillValue);
+  const kind = parsed[0].kind;
+  if (!parsed.every((p) => p.kind === kind)) return repeat();
+  const n = source.length;
+  if (kind === "number") {
+    if (n === 1) return repeat();
+    const values = parsed.map((p) => p.value);
+    return Array.from({ length: count }, (_, i) => String(roundFloat(linearTrend(values, n + i))));
+  }
+  if (kind === "date") {
+    const dates = parsed;
+    if (n === 1) {
+      return Array.from({ length: count }, (_, i) => formatDate(dates[0].time + (i + 1) * DAY_MS));
+    }
+    const monthIndex = dates.map((d) => d.year * 12 + (d.month - 1));
+    const monthStep = constantStep(monthIndex);
+    if (monthStep !== null && monthStep !== 0 && dates.every((d) => d.day === dates[0].day)) {
+      const last = monthIndex[n - 1];
+      return Array.from({ length: count }, (_, i) => {
+        const m = last + monthStep * (i + 1);
+        const year = Math.floor(m / 12);
+        const month = m - year * 12;
+        const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+        return formatDate(Date.UTC(year, month, Math.min(dates[0].day, daysInMonth)));
+      });
+    }
+    const dayStep = constantStep(dates.map((d) => Math.round(d.time / DAY_MS)));
+    if (dayStep === null) return repeat();
+    const lastTime = dates[n - 1].time;
+    return Array.from({ length: count }, (_, i) => formatDate(lastTime + dayStep * (i + 1) * DAY_MS));
+  }
+  if (kind === "textNumber") {
+    const items = parsed;
+    const { prefix, suffix } = items[0];
+    if (!items.every((t) => t.prefix === prefix && t.suffix === suffix)) return repeat();
+    const step = n === 1 ? 1 : constantStep(items.map((t) => t.value));
+    if (step === null) return repeat();
+    const last = items[n - 1];
+    return Array.from({ length: count }, (_, i) => {
+      const value = last.value + step * (i + 1);
+      const digits = value < 0 ? `-${pad(value, last.width)}` : pad(value, last.width);
+      return `${prefix}${digits}${suffix}`;
+    });
+  }
+  return repeat();
+}
+function computeFillTarget(source, pointer) {
+  const s = normalizeRange(source);
+  const rowOverflow = pointer.row > s.endRow ? pointer.row - s.endRow : pointer.row < s.startRow ? s.startRow - pointer.row : 0;
+  const colOverflow = pointer.col > s.endCol ? pointer.col - s.endCol : pointer.col < s.startCol ? s.startCol - pointer.col : 0;
+  if (rowOverflow === 0 && colOverflow === 0) return null;
+  if (rowOverflow >= colOverflow) {
+    return pointer.row > s.endRow ? { ...s, endRow: pointer.row } : { ...s, startRow: pointer.row };
+  }
+  return pointer.col > s.endCol ? { ...s, endCol: pointer.col } : { ...s, startCol: pointer.col };
+}
+function getFillDirection(source, target) {
+  const s = normalizeRange(source);
+  const t = normalizeRange(target);
+  const sameCols = s.startCol === t.startCol && s.endCol === t.endCol;
+  const sameRows = s.startRow === t.startRow && s.endRow === t.endRow;
+  if (sameCols && t.startRow === s.startRow && t.endRow > s.endRow) return "down";
+  if (sameCols && t.endRow === s.endRow && t.startRow < s.startRow) return "up";
+  if (sameRows && t.startCol === s.startCol && t.endCol > s.endCol) return "right";
+  if (sameRows && t.endCol === s.endCol && t.startCol < s.startCol) return "left";
+  return null;
+}
+
+// src/spreadsheet/csv.ts
+var BOM = "\uFEFF";
+function parseCsv(text, options = {}) {
+  const delimiter = options.delimiter ?? ",";
+  if (delimiter.length !== 1 || delimiter === '"' || delimiter === "\n" || delimiter === "\r") {
+    throw new Error(`Invalid CSV delimiter: ${JSON.stringify(delimiter)}`);
+  }
+  const input = text.startsWith(BOM) ? text.slice(1) : text;
+  const records = [];
+  let record = [];
+  let field = "";
+  let i = 0;
+  let recordStarted = false;
+  const endField = () => {
+    record.push(field);
+    field = "";
+  };
+  const endRecord = () => {
+    endField();
+    records.push(record);
+    record = [];
+    recordStarted = false;
+  };
+  let atFieldStart = true;
+  while (i < input.length) {
+    const char = input[i];
+    if (char === '"' && atFieldStart) {
+      const quoted = readQuoted(input, i, delimiter);
+      if (quoted.wellFormed || !options.requireWellFormedQuotes) {
+        recordStarted = true;
+        atFieldStart = false;
+        field += quoted.value;
+        i = quoted.end;
+        continue;
+      }
+    }
+    if (char === delimiter) {
+      recordStarted = true;
+      endField();
+      atFieldStart = true;
+      i++;
+      continue;
+    }
+    if (char === "\r" || char === "\n") {
+      endRecord();
+      atFieldStart = true;
+      i += char === "\r" && input[i + 1] === "\n" ? 2 : 1;
+      continue;
+    }
+    recordStarted = true;
+    atFieldStart = false;
+    field += char;
+    i++;
+  }
+  if (recordStarted || field !== "" || record.length > 0) endRecord();
+  return records;
+}
+function readQuoted(input, start, delimiter) {
+  let value = "";
+  let i = start + 1;
+  while (i < input.length) {
+    if (input[i] === '"') {
+      if (input[i + 1] === '"') {
+        value += '"';
+        i += 2;
+        continue;
+      }
+      const next = input[i + 1];
+      const wellFormed = next === void 0 || next === delimiter || next === "\r" || next === "\n";
+      return { value, end: i + 1, wellFormed };
+    }
+    value += input[i];
+    i++;
+  }
+  return { value, end: i, wellFormed: false };
+}
+function escapeCsvField(value, delimiter = ",", quoteAll = false) {
+  if (quoteAll || value.includes(delimiter) || /["\r\n]/.test(value)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function serializeCsv(rows, options = {}) {
+  const delimiter = options.delimiter ?? ",";
+  const lineEnding = options.lineEnding ?? "\r\n";
+  const body = rows.map(
+    (row) => row.map((value) => escapeCsvField(value == null ? "" : String(value), delimiter, options.quoteAll)).join(delimiter)
+  ).join(lineEnding);
+  return options.bom ? BOM + body : body;
+}
+function parseTsv(text) {
+  const normalized = text.startsWith(BOM) ? text.slice(1) : text;
+  if (!normalized.includes('"')) {
+    const body = normalized.replace(/\r\n?/g, "\n").replace(/\n$/, "");
+    return body === "" ? [] : body.split("\n").map((line) => line.split("	"));
+  }
+  return parseCsv(normalized, { delimiter: "	", requireWellFormedQuotes: true });
+}
+function serializeTsv(rows) {
+  return rows.map(
+    (row) => row.map((value) => {
+      const text = value == null ? "" : String(value);
+      return /[\t\r\n]/.test(text) || text.startsWith('"') ? `"${text.replace(/"/g, '""')}"` : text;
+    }).join("	")
+  ).join("\n");
+}
+
+// src/spreadsheet/clipboard.ts
+var SPREADSHEET_CLIPBOARD_MIME = "application/x.pixerate.spreadsheet+json";
+var displayText = (value) => value === null || value === void 0 ? "" : String(value);
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function serializeHtmlTable(values) {
+  const body = values.map(
+    (row) => `<tr>${row.map((v) => `<td>${escapeHtml(displayText(v)).replace(/\r?\n/g, "<br>")}</td>`).join("")}</tr>`
+  ).join("");
+  return `<table><tbody>${body}</tbody></table>`;
+}
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " "
+};
+function decodeEntities(text) {
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (match, entity) => {
+    if (entity[0] === "#") {
+      const code = entity[1] === "x" || entity[1] === "X" ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : match;
+    }
+    return NAMED_ENTITIES[entity.toLowerCase()] ?? match;
+  });
+}
+var LINE_BREAK = "\uE000";
+function cellHtmlToText(html) {
+  const text = html.replace(/<!--[\s\S]*?-->/g, "").replace(/<(style|script)[\s\S]*?<\/\1\s*>/gi, "").replace(/<br\s*\/?>/gi, LINE_BREAK).replace(/<\/(p|div)\s*>/gi, LINE_BREAK).replace(/<[^>]*>/g, "").replace(/\s+/g, " ");
+  return decodeEntities(text).replace(/ /g, " ").split(LINE_BREAK).map((line) => line.trim()).join("\n").replace(/^\n+|\n+$/g, "");
+}
+function parseHtmlTable(html) {
+  const tableMatch = /<table[\s>][\s\S]*?<\/table\s*>/i.exec(html);
+  if (!tableMatch) return null;
+  const table = tableMatch[0];
+  const rows = [];
+  const occupied = /* @__PURE__ */ new Map();
+  const rowPattern = /<tr[\s>]([\s\S]*?)<\/tr\s*>/gi;
+  const cellPattern = /<(td|th)(\s[^>]*)?>([\s\S]*?)<\/\1\s*>/gi;
+  let rowMatch;
+  let rowIndex = 0;
+  while (rowMatch = rowPattern.exec(table)) {
+    const row = [];
+    const taken = occupied.get(rowIndex) ?? /* @__PURE__ */ new Set();
+    let col = 0;
+    let cellMatch;
+    cellPattern.lastIndex = 0;
+    while (cellMatch = cellPattern.exec(rowMatch[1])) {
+      while (taken.has(col)) row[col++] = "";
+      const attrs = cellMatch[2] ?? "";
+      const colspan = Math.max(1, parseInt(/colspan\s*=\s*["']?(\d+)/i.exec(attrs)?.[1] ?? "1", 10));
+      const rowspan = Math.max(1, parseInt(/rowspan\s*=\s*["']?(\d+)/i.exec(attrs)?.[1] ?? "1", 10));
+      row[col] = cellHtmlToText(cellMatch[3]);
+      for (let c = col; c < col + colspan; c++) {
+        if (c > col) row[c] = "";
+        for (let r = rowIndex + 1; r < rowIndex + rowspan; r++) {
+          if (!occupied.has(r)) occupied.set(r, /* @__PURE__ */ new Set());
+          occupied.get(r).add(c);
+        }
+      }
+      col += colspan;
+    }
+    while (taken.has(col)) row[col++] = "";
+    rows.push(Array.from(row, (v) => v ?? ""));
+    rowIndex++;
+  }
+  return rows.length > 0 ? rows : null;
+}
+function createSpreadsheetClipboardData(cells, origin) {
+  const values = cells.map((row) => row.map((cell) => cell.value));
+  const payload = { type: "pixerate-spreadsheet", version: 1, origin, cells };
+  return {
+    "text/plain": serializeTsv(values.map((row) => row.map(displayText))),
+    "text/html": serializeHtmlTable(values),
+    [SPREADSHEET_CLIPBOARD_MIME]: JSON.stringify(payload)
+  };
+}
+function readFormat(source, format) {
+  try {
+    if (typeof source.getData === "function") {
+      return source.getData(format) ?? "";
+    }
+    return source[format] ?? "";
+  } catch {
+    return "";
+  }
+}
+function parsePayload(json) {
+  try {
+    const payload = JSON.parse(json);
+    if (payload?.type !== "pixerate-spreadsheet" || !Array.isArray(payload.cells) || !payload.cells.every((row) => Array.isArray(row)) || typeof payload.origin?.row !== "number" || typeof payload.origin?.col !== "number") {
+      return null;
+    }
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function readSpreadsheetClipboard(source) {
+  const payload = parsePayload(readFormat(source, SPREADSHEET_CLIPBOARD_MIME));
+  if (payload) {
+    return {
+      format: "internal",
+      origin: payload.origin,
+      rows: payload.cells.map((row) => row.map((cell) => typeof cell?.raw === "string" ? cell.raw : displayText(cell?.value)))
+    };
+  }
+  const html = readFormat(source, "text/html");
+  if (html) {
+    const rows = parseHtmlTable(html);
+    if (rows) return { format: "html", rows };
+  }
+  const text = readFormat(source, "text/plain");
+  if (text) {
+    const rows = parseTsv(text);
+    if (rows.length > 0) return { format: "text", rows };
+  }
+  return null;
+}
+function rebaseClipboardRows(rows, origin, target) {
+  const rowOffset = target.row - origin.row;
+  const colOffset = target.col - origin.col;
+  return rows.map(
+    (row) => row.map((raw) => raw.startsWith("=") ? offsetFormulaReferences(raw, rowOffset, colOffset) : raw)
+  );
+}
+
+// src/spreadsheet/view.ts
+var DEFAULT_ROW_HEIGHT = 32;
+var DEFAULT_COLUMN_WIDTH = 130;
+var clampCount = (value, max) => Math.max(0, Math.min(Math.floor(value ?? 0), max));
+function getTableSections(doc) {
+  const total = doc.rows.length;
+  const headerRows = clampCount(doc.table?.headerRowCount, total);
+  const footerRows = clampCount(doc.table?.footerRowCount, total - headerRows);
+  return { headerRows, footerRows };
+}
+function getRowSection(doc, rowIndex) {
+  const { headerRows, footerRows } = getTableSections(doc);
+  if (rowIndex < headerRows) return "header";
+  if (rowIndex >= doc.rows.length - footerRows) return "footer";
+  return "body";
+}
+function rowPassesFilters(doc, rowIndex, getValue) {
+  const filter = doc.table?.filter;
+  if (!filter?.enabled || filter.rules.length === 0) return true;
+  if (getRowSection(doc, rowIndex) !== "body") return true;
+  return filter.rules.every((rule) => {
+    const colIndex = doc.columns.findIndex((c) => c.id === rule.colId);
+    if (colIndex === -1) return true;
+    return matchesFilterRule(getValue(rowIndex, colIndex), rule);
+  });
+}
+function computeRowGroups(doc, getValue) {
+  const grouping = doc.table?.grouping;
+  if (!grouping) return [];
+  const groupCol = doc.columns.findIndex((c) => c.id === grouping.colId);
+  if (groupCol === -1) return [];
+  const { headerRows, footerRows } = getTableSections(doc);
+  const byKey = /* @__PURE__ */ new Map();
+  for (let r = headerRows; r < doc.rows.length - footerRows; r++) {
+    if (doc.rows[r].hidden || !rowPassesFilters(doc, r, getValue)) continue;
+    const value = getValue(r, groupCol);
+    const key = isBlankValue(value) ? "" : String(value).trim();
+    if (!byKey.has(key)) byKey.set(key, []);
+    byKey.get(key).push(r);
+  }
+  const collapsed = new Set(grouping.collapsed);
+  return Array.from(byKey.keys()).sort((a, b) => compareCellValues(a, b)).map((key) => {
+    const rowIndices = byKey.get(key);
+    const summaries = {};
+    for (const summary of grouping.summaries) {
+      const colIndex = doc.columns.findIndex((c) => c.id === summary.colId);
+      if (colIndex === -1) continue;
+      summaries[summary.colId] = aggregateValues(
+        rowIndices.map((r) => getValue(r, colIndex)),
+        summary.aggregate
+      );
+    }
+    return { key, label: key === "" ? "(blank)" : key, rowIndices, collapsed: collapsed.has(key), summaries };
+  });
+}
+function buildSpreadsheetView(doc, getValue) {
+  const { headerRows, footerRows } = getTableSections(doc);
+  const frozenRows = clampCount(doc.table?.frozenRowCount, doc.rows.length);
+  const frozenCols = clampCount(doc.table?.frozenColumnCount, doc.columns.length);
+  const headerCols = clampCount(doc.table?.headerColumnCount, doc.columns.length);
+  const columns = [];
+  let left = 0;
+  let hiddenColumnCount = 0;
+  doc.columns.forEach((column, index) => {
+    if (column.hidden) {
+      hiddenColumnCount++;
+      return;
+    }
+    const frozen = index < frozenCols;
+    columns.push({ column, index, header: index < headerCols, frozen, stickyLeft: frozen ? left : 0 });
+    if (frozen) left += column.width || DEFAULT_COLUMN_WIDTH;
+  });
+  const rows = [];
+  let hiddenRowCount = 0;
+  let filteredOutCount = 0;
+  const pushRow = (index, section, groupKey) => {
+    const row = doc.rows[index];
+    rows.push({ kind: "row", row, index, section, frozen: false, stickyTop: 0, groupKey });
+  };
+  for (let r = 0; r < headerRows; r++) {
+    if (doc.rows[r].hidden) hiddenRowCount++;
+    else pushRow(r, "header");
+  }
+  const bodyEnd = doc.rows.length - footerRows;
+  const groups = computeRowGroups(doc, getValue);
+  for (let r = headerRows; r < bodyEnd; r++) {
+    if (doc.rows[r].hidden) hiddenRowCount++;
+    else if (!rowPassesFilters(doc, r, getValue)) filteredOutCount++;
+  }
+  const grouping = doc.table?.grouping;
+  if (grouping && doc.columns.some((c) => c.id === grouping.colId)) {
+    for (const group of groups) {
+      rows.push({ kind: "group", group });
+      if (!group.collapsed) group.rowIndices.forEach((r) => pushRow(r, "body", group.key));
+    }
+  } else {
+    for (let r = headerRows; r < bodyEnd; r++) {
+      if (!doc.rows[r].hidden && rowPassesFilters(doc, r, getValue)) pushRow(r, "body");
+    }
+  }
+  for (let r = bodyEnd; r < doc.rows.length; r++) {
+    if (doc.rows[r].hidden) hiddenRowCount++;
+    else pushRow(r, "footer");
+  }
+  let top = 0;
+  for (const viewRow of rows) {
+    if (viewRow.kind !== "row" || viewRow.index >= frozenRows) break;
+    viewRow.frozen = true;
+    viewRow.stickyTop = top;
+    top += viewRow.row.height || DEFAULT_ROW_HEIGHT;
+  }
+  const rowOrder = rows.flatMap((r) => r.kind === "row" ? [r.index] : []);
+  const columnOrder = columns.map((c) => c.index);
+  const rowPos = new Map(rowOrder.map((index, pos) => [index, pos]));
+  const colPos = new Map(columnOrder.map((index, pos) => [index, pos]));
+  const spans = /* @__PURE__ */ new Map();
+  const contiguousRun = (indices, positions) => {
+    const visible = indices.filter((i) => positions.has(i)).sort((a, b) => positions.get(a) - positions.get(b));
+    if (visible.length === 0) return null;
+    let run = 1;
+    while (run < visible.length && positions.get(visible[run]) === positions.get(visible[0]) + run) run++;
+    return { first: visible[0], run };
+  };
+  for (const raw of doc.table?.merges ?? []) {
+    const merge = normalizeRange(raw);
+    const rowIdx = [];
+    const colIdx = [];
+    for (let r = merge.startRow; r <= merge.endRow; r++) rowIdx.push(r);
+    for (let c = merge.startCol; c <= merge.endCol; c++) colIdx.push(c);
+    const rowRun = contiguousRun(rowIdx, rowPos);
+    const colRun = contiguousRun(colIdx, colPos);
+    for (const r of rowIdx) for (const c of colIdx) spans.set(`${r}:${c}`, null);
+    if (rowRun && colRun) {
+      spans.set(`${rowRun.first}:${colRun.first}`, {
+        rowSpan: rowRun.run,
+        colSpan: colRun.run,
+        source: { row: merge.startRow, col: merge.startCol },
+        merge
+      });
+    }
+  }
+  return {
+    rows,
+    columns,
+    groups,
+    rowOrder,
+    columnOrder,
+    filteredOutCount,
+    hiddenRowCount,
+    hiddenColumnCount,
+    getCellSpan(row, col) {
+      const span = spans.get(`${row}:${col}`);
+      if (span === void 0) return { rowSpan: 1, colSpan: 1, source: { row, col } };
+      return span;
+    }
+  };
+}
+
+// src/spreadsheet/controller.ts
+var nextIdSequence = 0;
+var SpreadsheetController = class {
+  document;
+  activeCell = null;
+  selectedRange = null;
+  editingCell = null;
+  draftValue = "";
+  binder = new DataSourceBinder();
+  depGraph = new DependencyGraph();
+  evaluator;
+  primaryDataSourceId;
+  onDocumentChange;
+  onSelectionChange;
+  onCellCommit;
+  // History stack for undo/redo
+  undoStack = [];
+  redoStack = [];
+  isApplyingHistory = false;
+  // Set while importing TSV: history and recalculation are done once at the end.
+  batching = false;
+  pendingCommits = [];
+  // Row being evaluated, so [property] references resolve per row.
+  evaluatingRowIndex = null;
+  constructor(options = {}) {
+    const defaultCols = [
+      { id: "col_a", key: "A", title: "A", width: 120, type: "freeform" },
+      { id: "col_b", key: "B", title: "B", width: 120, type: "freeform" },
+      { id: "col_c", key: "C", title: "C", width: 120, type: "freeform" },
+      { id: "col_d", key: "D", title: "D", width: 120, type: "freeform" }
+    ];
+    const defaultRows = options.primaryDataSourceId ? [] : Array.from({ length: 10 }, (_, i) => ({
+      id: `row_${i + 1}`,
+      index: i,
+      height: 32,
+      type: "freeform"
+    }));
+    this.document = {
+      id: options.document?.id || `sheet_${Date.now()}`,
+      name: options.document?.name || "Sheet 1",
+      columns: options.document?.columns || defaultCols,
+      rows: options.document?.rows || defaultRows,
+      cells: options.document?.cells || {},
+      createdAt: options.document?.createdAt || Date.now(),
+      updatedAt: options.document?.updatedAt || Date.now(),
+      ...options.document?.table ? { table: options.document.table } : {}
+    };
+    this.primaryDataSourceId = options.primaryDataSourceId;
+    this.onDocumentChange = options.onDocumentChange;
+    this.onSelectionChange = options.onSelectionChange;
+    this.onCellCommit = options.onCellCommit;
+    if (options.dataSources) {
+      options.dataSources.forEach((ds) => this.binder.register(ds));
+    }
+    this.evaluator = new FormulaEvaluator({
+      resolveCell: (colStr, rowNum) => this.resolveCellByCoord(colStr, rowNum),
+      resolveRange: (sCol, sRow, eCol, eRow) => this.resolveRangeByCoords(sCol, sRow, eCol, eRow),
+      resolveProperty: (prop) => this.resolveCurrentRowProperty(prop)
+    });
+    this.syncWithDataSource();
+    this.recalculateAll();
+  }
+  loadDocument(document) {
+    this.document = JSON.parse(JSON.stringify(document));
+    this.activeCell = null;
+    this.selectedRange = null;
+    this.editingCell = null;
+    this.draftValue = "";
+    this.undoStack = [];
+    this.redoStack = [];
+    this.syncWithDataSource();
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  registerDataSource(ds) {
+    this.binder.register(ds);
+    this.syncWithDataSource();
+    this.recalculateAll();
+  }
+  setPrimaryDataSource(dataSourceId) {
+    this.primaryDataSourceId = dataSourceId;
+    this.syncWithDataSource();
+    this.recalculateAll();
+  }
+  syncWithDataSource() {
+    if (!this.primaryDataSourceId) return;
+    this.document.rows = this.binder.syncRows(this.document.rows, this.primaryDataSourceId);
+    this.recomputeRowIndices();
+  }
+  recomputeRowIndices() {
+    this.document.rows.forEach((r, idx) => {
+      r.index = idx;
+    });
+    this.document.columns.forEach((c, idx) => {
+      c.key = indexToColName(idx);
+    });
+  }
+  getColumn(colIdOrKey) {
+    return this.document.columns.find(
+      (c) => c.id === colIdOrKey || c.key.toUpperCase() === colIdOrKey.toUpperCase()
+    );
+  }
+  getRow(rowIdOrIndex) {
+    if (typeof rowIdOrIndex === "number") {
+      return this.document.rows[rowIdOrIndex];
+    }
+    return this.document.rows.find((r) => r.id === rowIdOrIndex);
+  }
+  getCell(rowId, colId) {
+    const existing = this.document.cells[rowId]?.[colId];
+    if (existing) return existing;
+    const col = this.document.columns.find((c) => c.id === colId);
+    const row = this.document.rows.find((r) => r.id === rowId);
+    return this.getDerivedCell(row, col);
+  }
+  /** Value of a cell with no stored data: bound record value, column formula, or blank. */
+  getDerivedCell(row, col) {
+    if (col && row && col.type === "bound" && col.binding && row.recordId) {
+      const boundVal = this.binder.resolveBoundValue(
+        col.binding.dataSource,
+        row.recordId,
+        col.binding.field
+      );
+      return {
+        raw: boundVal !== void 0 ? String(boundVal) : "",
+        value: boundVal ?? "",
+        format: col.format
+      };
+    }
+    if (col && col.type === "formula" && col.formula) {
+      return {
+        raw: col.formula,
+        value: "",
+        format: col.format
+      };
+    }
+    return { raw: "", value: "", format: col?.format };
+  }
+  setCellValue(rowId, colId, raw) {
+    this.recordSnapshot();
+    if (!this.document.cells[rowId]) {
+      this.document.cells[rowId] = {};
+    }
+    const col = this.document.columns.find((c) => c.id === colId);
+    const row = this.document.rows.find((r) => r.id === rowId);
+    if (col?.type === "bound" && col.binding && row?.recordId) {
+      this.binder.commitBoundValue(
+        col.binding.dataSource,
+        row.recordId,
+        col.binding.field,
+        raw
+      );
+    }
+    const cellKey = this.getCellKey(rowId, colId);
+    this.depGraph.setCellFormula(cellKey, raw.startsWith("=") ? raw : null);
+    this.document.cells[rowId][colId] = {
+      raw,
+      value: raw,
+      format: col?.format
+    };
+    this.document.updatedAt = Date.now();
+    if (this.batching) {
+      this.pendingCommits.push([rowId, colId, raw]);
+      return;
+    }
+    this.recalculateCell(rowId, colId);
+    this.notifyChange();
+    const evaluatedVal = this.document.cells[rowId][colId]?.value;
+    this.onCellCommit?.(rowId, colId, raw, evaluatedVal);
+  }
+  getCellKey(rowId, colId) {
+    const row = this.document.rows.find((r) => r.id === rowId);
+    const col = this.document.columns.find((c) => c.id === colId);
+    if (!row || !col) return `${colId}_${rowId}`;
+    return `${col.key}${row.index + 1}`.toUpperCase();
+  }
+  /**
+   * Recalculates a cell and everything that depends on it, in dependency
+   * order. Every cell in a reference cycle is marked `#CYCLE!`.
+   */
+  recalculateCell(rowId, colId) {
+    const cellKey = this.getCellKey(rowId, colId);
+    this.runEvaluationPlan(this.depGraph.getEvaluationPlan([cellKey], { includeDependents: true }));
+  }
+  /**
+   * Rebuilds the dependency graph from scratch and recalculates every formula
+   * in dependency order.
+   */
+  recalculateAll() {
+    this.depGraph.clear();
+    const formulaKeys = [];
+    for (const row of this.document.rows) {
+      for (const col of this.document.columns) {
+        const cell = this.document.cells[row.id]?.[col.id] ?? this.getDerivedCell(row, col);
+        if (cell.raw.startsWith("=")) {
+          const cellKey = `${col.key}${row.index + 1}`.toUpperCase();
+          this.depGraph.setCellFormula(cellKey, cell.raw);
+          formulaKeys.push(cellKey);
+        }
+      }
+    }
+    this.runEvaluationPlan(this.depGraph.getEvaluationPlan(formulaKeys));
+  }
+  runEvaluationPlan(plan) {
+    for (const key of plan.order) {
+      if (plan.cyclic.has(key)) {
+        this.markCycle(key);
+      } else {
+        this.evalSingleCellByKey(key);
+      }
+    }
+  }
+  locateCellKey(cellKey) {
+    const match = cellKey.match(/^([A-Za-z]+)(\d+)$/);
+    if (!match) return null;
+    const col = this.document.columns.find((c) => c.key.toUpperCase() === match[1].toUpperCase());
+    const row = this.document.rows[parseInt(match[2], 10) - 1];
+    return col && row ? { row, col } : null;
+  }
+  markCycle(cellKey) {
+    const located = this.locateCellKey(cellKey);
+    if (!located) return;
+    const { row, col } = located;
+    const cell = this.getCell(row.id, col.id);
+    if (!cell.raw.startsWith("=")) return;
+    if (!this.document.cells[row.id]) this.document.cells[row.id] = {};
+    const deps = this.depGraph.getDependencies(cellKey);
+    const selfReference = deps.includes(cellKey) || deps.includes(`${col.key.toUpperCase()}:`);
+    const errorMessage = selfReference ? "This formula can't reference its own cell." : "This formula is part of a circular reference: it depends on its own result through other cells.";
+    this.document.cells[row.id][col.id] = { ...cell, value: "#CYCLE!", error: "#CYCLE!", errorMessage };
+  }
+  evalSingleCellByKey(cellKey) {
+    const match = cellKey.match(/^([A-Za-z]+)(\d+)$/);
+    if (!match) return;
+    const colName = match[1].toUpperCase();
+    const rowNum = parseInt(match[2], 10);
+    const col = this.document.columns.find((c) => c.key.toUpperCase() === colName);
+    const row = this.document.rows[rowNum - 1];
+    if (!col || !row) return;
+    const cell = this.getCell(row.id, col.id);
+    if (!cell.raw.startsWith("=")) {
+      if (cell.error === "#CYCLE!") {
+        cell.error = void 0;
+        cell.errorMessage = void 0;
+      }
+      return;
+    }
+    try {
+      this.evaluatingRowIndex = rowNum - 1;
+      const result = this.evaluator.evaluateWithDiagnostics(cell.raw);
+      if (!this.document.cells[row.id]) {
+        this.document.cells[row.id] = {};
+      }
+      this.document.cells[row.id][col.id] = {
+        ...cell,
+        value: result.value,
+        // `#ERROR!` (malformed formula, wrong argument count) keeps its
+        // message in `error`, as before; other errors store their code.
+        error: result.error === "#ERROR!" ? result.message : result.error,
+        errorMessage: result.message
+      };
+    } finally {
+      this.evaluatingRowIndex = null;
+    }
+  }
+  resolveCellByCoord(colStr, rowNum) {
+    const col = this.document.columns.find((c) => c.key.toUpperCase() === colStr.toUpperCase());
+    const row = this.document.rows[rowNum - 1];
+    if (!col || !row) return 0;
+    return this.getCell(row.id, col.id).value ?? "";
+  }
+  resolveRangeByCoords(sCol, sRow, eCol, eRow) {
+    const startC = colNameToIndex(sCol);
+    const endC = colNameToIndex(eCol);
+    const minC = Math.min(startC, endC);
+    const maxC = Math.max(startC, endC);
+    const minR = Math.min(sRow, eRow);
+    const maxR = Math.min(Math.max(sRow, eRow), WHOLE_COLUMN_END_ROW, this.document.rows.length);
+    const results = [];
+    for (let c = minC; c <= maxC; c++) {
+      const colName = indexToColName(c);
+      const col = this.document.columns.find((colDef) => colDef.key.toUpperCase() === colName);
+      if (!col) continue;
+      for (let r = minR; r <= maxR; r++) {
+        const row = this.document.rows[r - 1];
+        if (!row) continue;
+        results.push(this.getCell(row.id, col.id).value ?? "");
+      }
+    }
+    return results;
+  }
+  resolveCurrentRowProperty(prop) {
+    const rowIndex = this.evaluatingRowIndex ?? this.activeCell?.row;
+    if (rowIndex === void 0 || rowIndex === null) return 0;
+    const row = this.document.rows[rowIndex];
+    if (!row || !row.recordId || !this.primaryDataSourceId) return 0;
+    return this.binder.resolveBoundValue(this.primaryDataSourceId, row.recordId, prop) ?? 0;
+  }
+  // --- Selection and Navigation ---
+  selectCell(row, col, extendSelection = false) {
+    const clampedRow = Math.max(0, Math.min(row, this.document.rows.length - 1));
+    const clampedCol = Math.max(0, Math.min(col, this.document.columns.length - 1));
+    const merge = extendSelection ? null : this.getMergeAt(clampedRow, clampedCol);
+    const activeRow = merge ? merge.startRow : clampedRow;
+    const activeCol = merge ? merge.startCol : clampedCol;
+    const rowObj = this.document.rows[activeRow];
+    const colObj = this.document.columns[activeCol];
+    this.activeCell = {
+      row: activeRow,
+      col: activeCol,
+      rowId: rowObj?.id,
+      colId: colObj?.id
+    };
+    if (extendSelection && this.selectedRange) {
+      this.selectedRange = this.expandRangeToMerges({
+        startRow: this.selectedRange.startRow,
+        startCol: this.selectedRange.startCol,
+        endRow: clampedRow,
+        endCol: clampedCol
+      });
+    } else if (merge) {
+      this.selectedRange = { ...merge };
+    } else {
+      this.selectedRange = {
+        startRow: clampedRow,
+        startCol: clampedCol,
+        endRow: clampedRow,
+        endCol: clampedCol
+      };
+    }
+    this.onSelectionChange?.(this.activeCell, this.selectedRange);
+  }
+  selectRange(range) {
+    this.selectedRange = range;
+    this.onSelectionChange?.(this.activeCell, this.selectedRange);
+  }
+  startEditing(row, col, initialValue) {
+    this.selectCell(row ?? this.activeCell?.row ?? 0, col ?? this.activeCell?.col ?? 0);
+    const targetRow = this.activeCell?.row ?? 0;
+    const targetCol = this.activeCell?.col ?? 0;
+    const rowObj = this.document.rows[targetRow];
+    const colObj = this.document.columns[targetCol];
+    if (!rowObj || !colObj) return;
+    this.editingCell = {
+      row: targetRow,
+      col: targetCol,
+      rowId: rowObj.id,
+      colId: colObj.id
+    };
+    const cell = this.getCell(rowObj.id, colObj.id);
+    this.draftValue = initialValue !== void 0 ? initialValue : cell.raw;
+  }
+  commitEditing(valueToCommit) {
+    if (!this.editingCell) return;
+    const val = valueToCommit !== void 0 ? valueToCommit : this.draftValue;
+    if (this.editingCell.rowId && this.editingCell.colId) {
+      this.setCellValue(this.editingCell.rowId, this.editingCell.colId, val);
+    }
+    this.editingCell = null;
+    this.draftValue = "";
+  }
+  cancelEditing() {
+    this.editingCell = null;
+    this.draftValue = "";
+  }
+  moveCursor(direction, extendSelection = false) {
+    if (!this.activeCell) {
+      this.selectCell(0, 0);
+      return;
+    }
+    const { rowOrder, columnOrder } = this.getViewModel();
+    let nextRow = this.activeCell.row;
+    let nextCol = this.activeCell.col;
+    const merge = extendSelection ? null : this.getMergeAt(nextRow, nextCol);
+    switch (direction) {
+      case "up":
+        nextRow = stepInOrder(rowOrder, merge ? merge.startRow : nextRow, -1);
+        break;
+      case "down":
+        nextRow = stepInOrder(rowOrder, merge ? merge.endRow : nextRow, 1);
+        break;
+      case "left":
+        nextCol = stepInOrder(columnOrder, merge ? merge.startCol : nextCol, -1);
+        break;
+      case "right":
+        nextCol = stepInOrder(columnOrder, merge ? merge.endCol : nextCol, 1);
+        break;
+    }
+    this.selectCell(nextRow, nextCol, extendSelection);
+  }
+  // --- Grid Structure Mutations ---
+  insertColumn(index, config) {
+    this.recordSnapshot();
+    const newId = config?.id || this.generateId("col");
+    const newCol = {
+      id: newId,
+      key: indexToColName(index),
+      title: config?.title || indexToColName(index),
+      width: config?.width || 130,
+      type: config?.type || "freeform",
+      binding: config?.binding,
+      formula: config?.formula,
+      format: config?.format || "text",
+      readOnly: config?.readOnly
+    };
+    this.shiftReferences({ axis: "col", index, type: "insert" });
+    this.adjustTableForStructuralChange({ axis: "col", index, type: "insert" });
+    this.document.columns.splice(index, 0, newCol);
+    this.recomputeRowIndices();
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  deleteColumn(colId) {
+    this.recordSnapshot();
+    const colIndex = this.document.columns.findIndex((c) => c.id === colId);
+    if (colIndex === -1) return;
+    this.shiftReferences({ axis: "col", index: colIndex, type: "delete" });
+    this.adjustTableForStructuralChange({ axis: "col", index: colIndex, type: "delete" });
+    this.document.columns = this.document.columns.filter((c) => c.id !== colId);
+    for (const rowId of Object.keys(this.document.cells)) {
+      delete this.document.cells[rowId][colId];
+    }
+    this.recomputeRowIndices();
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  insertRow(index, config) {
+    this.recordSnapshot();
+    const newId = config?.id || this.generateId("row");
+    const newRow = {
+      id: newId,
+      index,
+      height: config?.height || 32,
+      recordId: config?.recordId,
+      type: config?.type || "freeform"
+    };
+    this.shiftReferences({ axis: "row", index, type: "insert" });
+    this.adjustTableForStructuralChange({ axis: "row", index, type: "insert" });
+    this.document.rows.splice(index, 0, newRow);
+    this.recomputeRowIndices();
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  deleteRow(rowId) {
+    this.recordSnapshot();
+    const rowIndex = this.document.rows.findIndex((r) => r.id === rowId);
+    if (rowIndex === -1) return;
+    this.shiftReferences({ axis: "row", index: rowIndex, type: "delete" });
+    this.adjustTableForStructuralChange({ axis: "row", index: rowIndex, type: "delete" });
+    this.document.rows = this.document.rows.filter((r) => r.id !== rowId);
+    delete this.document.cells[rowId];
+    this.recomputeRowIndices();
+    this.recalculateAll();
+    this.notifyChange();
+  }
+  generateId(prefix) {
+    return `${prefix}_${Date.now()}_${(nextIdSequence++).toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+  }
+  /**
+   * Rewrites references in every cell formula (and, for column changes, every
+   * column formula) so they keep pointing at the same cells.
+   */
+  shiftReferences(change) {
+    for (const rowCells of Object.values(this.document.cells)) {
+      for (const cell of Object.values(rowCells)) {
+        if (cell.raw?.startsWith("=")) {
+          cell.raw = shiftFormulaReferences(cell.raw, change);
+        }
+      }
+    }
+    if (change.axis === "col") {
+      for (const col of this.document.columns) {
+        if (col.formula?.startsWith("=")) {
+          col.formula = shiftFormulaReferences(col.formula, change);
+        }
+      }
+    }
+  }
+  setColumnWidth(colId, width) {
+    const col = this.document.columns.find((c) => c.id === colId);
+    if (col) {
+      col.width = Math.max(30, width);
+      this.notifyChange();
+    }
+  }
+  autoFitColumnWidth(colId, customWidth) {
+    if (customWidth !== void 0) {
+      this.setColumnWidth(colId, customWidth);
+      return;
+    }
+    const col = this.document.columns.find((c) => c.id === colId);
+    if (!col) return;
+    let maxLen = (col.title || "").length + (col.key ? col.key.length + 3 : 0);
+    for (const row of this.document.rows) {
+      const cell = this.getCell(row.id, col.id);
+      const valStr = cell.value != null ? String(cell.value) : "";
+      if (valStr.length > maxLen) {
+        maxLen = valStr.length;
+      }
+    }
+    const estimatedWidth = Math.min(600, Math.max(50, Math.ceil(maxLen * 8.5 + 32)));
+    this.setColumnWidth(colId, estimatedWidth);
+  }
+  // --- Clipboard TSV/CSV ---
+  /**
+   * Exports cell values as TSV: the whole sheet, or only `range` (e.g. the
+   * current selection) when given.
+   */
+  exportToTsv(range) {
+    const rows = range ? this.document.rows.slice(
+      Math.min(range.startRow, range.endRow),
+      Math.max(range.startRow, range.endRow) + 1
+    ) : this.document.rows;
+    const columns = range ? this.document.columns.slice(
+      Math.min(range.startCol, range.endCol),
+      Math.max(range.startCol, range.endCol) + 1
+    ) : this.document.columns;
+    return rows.map(
+      (row) => columns.map((col) => {
+        const cell = this.getCell(row.id, col.id);
+        return String(cell.value ?? "").replace(/\t/g, " ");
+      }).join("	")
+    ).join("\n");
+  }
+  /**
+   * Pastes tab-separated values starting at (startRow, startCol), adding rows
+   * and columns as needed. The whole paste is a single undo step.
+   */
+  importFromTsv(tsvData, startRow = 0, startCol = 0) {
+    const normalized = tsvData.replace(/\r\n?/g, "\n").replace(/\n$/, "");
+    if (normalized === "") return;
+    this.writeMatrix(normalized.split("\n").map((line) => line.split("	")), startRow, startCol);
+  }
+  /** Adds rows/columns at the end until (rowIndex, colIndex) exists. */
+  growGrid(rowIndex, colIndex) {
+    while (rowIndex >= this.document.rows.length) {
+      const index = this.document.rows.length;
+      this.document.rows.push({ id: this.generateId("row"), index, height: 32, type: "freeform" });
+    }
+    while (colIndex >= this.document.columns.length) {
+      const key = indexToColName(this.document.columns.length);
+      this.document.columns.push({
+        id: this.generateId("col"),
+        key,
+        title: key,
+        width: 130,
+        type: "freeform",
+        format: "text"
+      });
+    }
+  }
+  /**
+   * Writes raw inputs starting at (startRow, startCol), growing the grid as
+   * needed, as a single undo step with one recalculation.
+   */
+  writeMatrix(matrix, startRow, startCol) {
+    if (matrix.length === 0) return;
+    this.runBatch(() => {
+      matrix.forEach((line, rIdx) => {
+        line.forEach((val, cIdx) => {
+          this.growGrid(startRow + rIdx, startCol + cIdx);
+          const row = this.document.rows[startRow + rIdx];
+          this.setCellValue(row.id, this.document.columns[startCol + cIdx].id, val);
+        });
+      });
+    });
+  }
+  /**
+   * Runs `fn` as one undo step: cell writes inside it are batched and
+   * recalculated once, then listeners are notified.
+   */
+  runBatch(fn) {
+    this.recordSnapshot();
+    this.batching = true;
+    this.pendingCommits = [];
+    try {
+      fn();
+    } finally {
+      this.batching = false;
+    }
+    this.recomputeRowIndices();
+    this.recalculateAll();
+    this.document.updatedAt = Date.now();
+    this.notifyChange();
+    const commits = this.pendingCommits;
+    this.pendingCommits = [];
+    for (const [rowId, colId, raw] of commits) {
+      this.onCellCommit?.(rowId, colId, raw, this.document.cells[rowId]?.[colId]?.value);
+    }
+  }
+  // --- CSV ---
+  /**
+   * Exports the sheet (or `range`) as RFC 4180 CSV. Values are exported as
+   * displayed unless `formulas` is set.
+   */
+  exportToCsv(options = {}) {
+    const matrix = this.readMatrix(options.range ?? null).map(
+      (row) => row.map((cell) => options.formulas ? cell.raw : String(cell.value ?? ""))
+    );
+    return serializeCsv(matrix, {
+      delimiter: options.delimiter,
+      lineEnding: options.lineEnding,
+      bom: options.bom
+    });
+  }
+  /**
+   * Imports CSV text at (startRow, startCol) (default A1), growing the grid
+   * as needed. The whole import is a single undo step.
+   */
+  importFromCsv(csv, options = {}) {
+    const matrix = parseCsv(csv, { delimiter: options.delimiter });
+    this.writeMatrix(matrix, options.startRow ?? 0, options.startCol ?? 0);
+  }
+  /**
+   * Writes already-parsed rows of raw inputs (e.g. from an import adapter)
+   * starting at (startRow, startCol), as a single undo step.
+   */
+  importRows(rows, options = {}) {
+    this.writeMatrix(rows, options.startRow ?? 0, options.startCol ?? 0);
+  }
+  /** The cells of `range` (or the whole sheet), row by row. */
+  readMatrix(range) {
+    const r = range ? normalizeRange(range) : null;
+    const rows = r ? this.document.rows.slice(r.startRow, r.endRow + 1) : this.document.rows;
+    const columns = r ? this.document.columns.slice(r.startCol, r.endCol + 1) : this.document.columns;
+    return rows.map((row) => columns.map((col) => this.getCell(row.id, col.id)));
+  }
+  // --- Spreadsheet clipboard ---
+  /**
+   * Builds clipboard data for `range` (default: the selection) as TSV,
+   * an HTML table and the lossless internal JSON format. Write every entry
+   * with `clipboardData.setData(type, data)` in a `copy` event.
+   */
+  copyToClipboardData(range = this.selectedRange) {
+    const r = range ? normalizeRange(range) : { startRow: 0, startCol: 0, endRow: this.document.rows.length - 1, endCol: this.document.columns.length - 1 };
+    const cells = this.readMatrix(r).map((row) => row.map((cell) => ({ raw: cell.raw, value: cell.error || cell.value })));
+    return createSpreadsheetClipboardData(cells, { row: r.startRow, col: r.startCol });
+  }
+  /**
+   * Pastes clipboard data at `target` (default: the selection's top-left).
+   * Prefers the internal format (formulas re-based to the target), then an
+   * HTML table, then TSV. Returns false when there was nothing to paste.
+   */
+  pasteClipboardData(source, target) {
+    const parsed = readSpreadsheetClipboard(source);
+    if (!parsed) return false;
+    const at = target ?? this.getSelectionTopLeft();
+    const rows = parsed.origin ? rebaseClipboardRows(parsed.rows, parsed.origin, at) : parsed.rows;
+    this.writeMatrix(rows, at.row, at.col);
+    const r = normalizeRange({
+      startRow: at.row,
+      startCol: at.col,
+      endRow: at.row + rows.length - 1,
+      endCol: at.col + rows.reduce((max, row) => Math.max(max, row.length), 1) - 1
+    });
+    this.selectRange(r);
+    return true;
+  }
+  getSelectionTopLeft() {
+    if (this.selectedRange) {
+      const r = normalizeRange(this.selectedRange);
+      return { row: r.startRow, col: r.startCol };
+    }
+    return { row: this.activeCell?.row ?? 0, col: this.activeCell?.col ?? 0 };
+  }
+  // --- Table operations: shared helpers ---
+  /** The table settings object, created on first use. */
+  get table() {
+    if (!this.document.table) this.document.table = {};
+    return this.document.table;
+  }
+  /** Records an undo step, applies `fn`, then notifies listeners. */
+  applyTableChange(fn, options = {}) {
+    this.recordSnapshot();
+    fn();
+    if (options.recalculate) {
+      this.recomputeRowIndices();
+      this.recalculateAll();
+    }
+    this.document.updatedAt = Date.now();
+    this.notifyChange();
+  }
+  /** First and last (inclusive) body row: rows between header and footer rows. */
+  getBodyRowBounds() {
+    const { headerRows, footerRows } = getTableSections(this.document);
+    return { start: headerRows, end: this.document.rows.length - footerRows - 1 };
+  }
+  getCellValueAt = (rowIndex, colIndex) => {
+    const row = this.document.rows[rowIndex];
+    const col = this.document.columns[colIndex];
+    if (!row || !col) return "";
+    return this.getCell(row.id, col.id).value;
+  };
+  /** Rewrites every formula so references follow cells that moved. */
+  remapAllFormulas(moveCell) {
+    for (const rowCells of Object.values(this.document.cells)) {
+      for (const cell of Object.values(rowCells)) {
+        if (cell.raw?.startsWith("=")) {
+          cell.raw = remapFormulaReferences(cell.raw, moveCell);
+        }
+      }
+    }
+  }
+  /**
+   * Keeps merges in place when rows/columns are inserted or deleted:
+   * merges after the change shift, merges across it grow or shrink, and
+   * merges reduced to a single cell are dropped.
+   */
+  adjustTableForStructuralChange(change) {
+    const merges = this.document.table?.merges;
+    if (!merges?.length) return;
+    const startKey = change.axis === "row" ? "startRow" : "startCol";
+    const endKey = change.axis === "row" ? "endRow" : "endCol";
+    const next = [];
+    for (const merge of merges) {
+      const m = { ...merge };
+      if (change.type === "insert") {
+        if (m[startKey] >= change.index) m[startKey]++;
+        if (m[endKey] >= change.index) m[endKey]++;
+      } else {
+        if (m[startKey] === change.index && m[endKey] === change.index) continue;
+        if (m[startKey] > change.index) m[startKey]--;
+        if (m[endKey] >= change.index) m[endKey]--;
+      }
+      if (!isSingleCellRange(m)) next.push(m);
+    }
+    this.document.table.merges = next;
+  }
+  // --- Sort ---
+  /**
+   * Sorts rows by one or more columns (stable; numbers before text, blanks
+   * last). Without a range (or with a range spanning every column) whole rows
+   * move; with a range only the cells inside it move. Header and footer rows
+   * never move. References follow the moved cells. Returns false when the
+   * sort is rejected (no valid keys, a key outside the range, or merged
+   * cells in the sorted area).
+   */
+  sortRows(keys, options = {}) {
+    const colCount = this.document.columns.length;
+    const body = this.getBodyRowBounds();
+    const range = options.range ? normalizeRange(options.range) : null;
+    const startRow = Math.max(range?.startRow ?? body.start, body.start);
+    const endRow = Math.min(range?.endRow ?? body.end, body.end);
+    const startCol = range ? Math.max(0, range.startCol) : 0;
+    const endCol = range ? Math.min(colCount - 1, range.endCol) : colCount - 1;
+    if (endRow - startRow < 1 || startCol > endCol) return false;
+    const keyCols = keys.map((key) => ({
+      index: this.document.columns.findIndex((c) => c.id === key.colId),
+      direction: key.direction ?? "asc"
+    }));
+    if (keyCols.length === 0 || keyCols.some((k) => k.index < startCol || k.index > endCol)) return false;
+    const area = { startRow, startCol, endRow, endCol };
+    if ((this.document.table?.merges ?? []).some((m) => rangesIntersect(m, area))) return false;
+    const sourceRows = [];
+    for (let r = startRow; r <= endRow; r++) sourceRows.push(r);
+    const sorted = sourceRows.map((r) => ({ r, values: keyCols.map((k) => this.getCellValueAt(r, k.index)) })).sort((a, b) => {
+      for (let i = 0; i < keyCols.length; i++) {
+        const result = compareCellValues(a.values[i], b.values[i], keyCols[i].direction);
+        if (result !== 0) return result;
+      }
+      return a.r - b.r;
+    }).map((entry) => entry.r);
+    if (sorted.every((r, i) => r === sourceRows[i])) return true;
+    const newIndexOf = /* @__PURE__ */ new Map();
+    sorted.forEach((oldRow, i) => newIndexOf.set(oldRow, startRow + i));
+    const wholeRows = startCol === 0 && endCol === colCount - 1;
+    this.applyTableChange(() => {
+      this.remapAllFormulas(({ row, col }) => {
+        const target = newIndexOf.get(row);
+        if (target === void 0 || col < startCol || col > endCol) return null;
+        return { row: target, col };
+      });
+      if (wholeRows) {
+        const moved = sorted.map((r) => this.document.rows[r]);
+        this.document.rows.splice(startRow, moved.length, ...moved);
+      } else {
+        const colIds = this.document.columns.slice(startCol, endCol + 1).map((c) => c.id);
+        const snapshot = sorted.map((oldRow) => {
+          const rowId = this.document.rows[oldRow].id;
+          return colIds.map((colId) => this.document.cells[rowId]?.[colId]);
+        });
+        snapshot.forEach((cells, i) => {
+          const rowId = this.document.rows[startRow + i].id;
+          if (!this.document.cells[rowId]) this.document.cells[rowId] = {};
+          colIds.forEach((colId, c) => {
+            if (cells[c]) this.document.cells[rowId][colId] = cells[c];
+            else delete this.document.cells[rowId][colId];
+          });
+        });
+      }
+    }, { recalculate: true });
+    return true;
+  }
+  // --- Filters ---
+  getFilterState() {
+    return this.document.table?.filter ?? { enabled: false, rules: [] };
+  }
+  /** Replaces all filter rules (and turns filters on when there are any). */
+  setFilterRules(rules) {
+    this.applyTableChange(() => {
+      this.table.filter = {
+        enabled: rules.length > 0,
+        rules: rules.map((rule) => ({ ...rule, id: rule.id ?? this.generateFilterId() }))
+      };
+    });
+  }
+  /** Adds a filter rule (AND-combined with the others) and turns filters on. Returns its id. */
+  addFilterRule(rule) {
+    const id = rule.id ?? this.generateFilterId();
+    this.applyTableChange(() => {
+      const current = this.getFilterState();
+      this.table.filter = { enabled: true, rules: [...current.rules, { ...rule, id }] };
+    });
+    return id;
+  }
+  updateFilterRule(ruleId, changes) {
+    const current = this.getFilterState();
+    if (!current.rules.some((r) => r.id === ruleId)) return;
+    this.applyTableChange(() => {
+      this.table.filter = {
+        ...current,
+        rules: current.rules.map((r) => r.id === ruleId ? { ...r, ...changes } : r)
+      };
+    });
+  }
+  removeFilterRule(ruleId) {
+    const current = this.getFilterState();
+    if (!current.rules.some((r) => r.id === ruleId)) return;
+    this.applyTableChange(() => {
+      this.table.filter = { ...current, rules: current.rules.filter((r) => r.id !== ruleId) };
+    });
+  }
+  clearFilters() {
+    if (this.getFilterState().rules.length === 0) return;
+    this.applyTableChange(() => {
+      this.table.filter = { enabled: false, rules: [] };
+    });
+  }
+  /** Turns filtering on or off, keeping the rules. */
+  setFiltersEnabled(enabled) {
+    const current = this.getFilterState();
+    if (current.enabled === enabled) return;
+    this.applyTableChange(() => {
+      this.table.filter = { ...current, enabled };
+    });
+  }
+  toggleFilters() {
+    this.setFiltersEnabled(!this.getFilterState().enabled);
+  }
+  generateFilterId() {
+    return `filter_${Date.now()}_${(nextIdSequence++).toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+  }
+  // --- Header, footer and frozen rows/columns ---
+  setHeaderRowCount(count) {
+    this.setTableCount("headerRowCount", count, this.document.rows.length);
+  }
+  setFooterRowCount(count) {
+    this.setTableCount("footerRowCount", count, this.document.rows.length);
+  }
+  setHeaderColumnCount(count) {
+    this.setTableCount("headerColumnCount", count, this.document.columns.length);
+  }
+  /** Keeps the first `count` rows visible while scrolling. 0 unfreezes. */
+  setFrozenRowCount(count) {
+    this.setTableCount("frozenRowCount", count, this.document.rows.length);
+  }
+  /** Keeps the first `count` columns visible while scrolling. 0 unfreezes. */
+  setFrozenColumnCount(count) {
+    this.setTableCount("frozenColumnCount", count, this.document.columns.length);
+  }
+  setTableCount(key, count, max) {
+    const value = Math.max(0, Math.min(Math.floor(count), max));
+    if ((this.document.table?.[key] ?? 0) === value) return;
+    this.applyTableChange(() => {
+      this.table[key] = value;
+    });
+  }
+  // --- Hide / unhide ---
+  hideRows(indices) {
+    this.setHidden("row", indices, true);
+  }
+  unhideRows(indices) {
+    this.setHidden("row", indices, false);
+  }
+  hideColumns(indices) {
+    this.setHidden("col", indices, true);
+  }
+  unhideColumns(indices) {
+    this.setHidden("col", indices, false);
+  }
+  /** Unhides every hidden row and column (filters are unaffected). */
+  unhideAll() {
+    const rows = this.document.rows.flatMap((r, i) => r.hidden ? [i] : []);
+    const cols = this.document.columns.flatMap((c, i) => c.hidden ? [i] : []);
+    if (rows.length === 0 && cols.length === 0) return;
+    this.applyTableChange(() => {
+      rows.forEach((i) => delete this.document.rows[i].hidden);
+      cols.forEach((i) => delete this.document.columns[i].hidden);
+    });
+  }
+  setHidden(axis, indices, hidden) {
+    const items = axis === "row" ? this.document.rows : this.document.columns;
+    const targets = indices.filter((i) => items[i] && !!items[i].hidden !== hidden);
+    if (targets.length === 0) return;
+    this.applyTableChange(() => {
+      for (const i of targets) {
+        if (hidden) items[i].hidden = true;
+        else delete items[i].hidden;
+      }
+    });
+  }
+  // --- Merged cells ---
+  getMerges() {
+    return this.document.table?.merges ?? [];
+  }
+  /** The merge containing (row, col), or null. */
+  getMergeAt(row, col) {
+    return this.getMerges().find((m) => rangeContains(m, row, col)) ?? null;
+  }
+  /** Grows `range` until no merge crosses its edge. Keeps the drag direction. */
+  expandRangeToMerges(range) {
+    let r = normalizeRange(range);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const m of this.getMerges()) {
+        if (rangesIntersect(m, r) && !rangeContainsRange(r, m)) {
+          r = {
+            startRow: Math.min(r.startRow, m.startRow),
+            startCol: Math.min(r.startCol, m.startCol),
+            endRow: Math.max(r.endRow, m.endRow),
+            endCol: Math.max(r.endCol, m.endCol)
+          };
+          changed = true;
+        }
+      }
+    }
+    const rowsReversed = range.startRow > range.endRow;
+    const colsReversed = range.startCol > range.endCol;
+    return {
+      startRow: rowsReversed ? r.endRow : r.startRow,
+      endRow: rowsReversed ? r.startRow : r.endRow,
+      startCol: colsReversed ? r.endCol : r.startCol,
+      endCol: colsReversed ? r.startCol : r.endCol
+    };
+  }
+  /**
+   * Merges `range` (default: the selection) into one cell anchored on its
+   * top-left cell; the other cells are cleared. Merges fully inside the range
+   * are absorbed. Returns false for single cells and for ranges that
+   * partially overlap an existing merge.
+   */
+  mergeCells(range = this.selectedRange) {
+    if (!range) return false;
+    const r = normalizeRange(range);
+    if (isSingleCellRange(r) || r.startRow < 0 || r.startCol < 0 || r.endRow >= this.document.rows.length || r.endCol >= this.document.columns.length) {
+      return false;
+    }
+    const merges = this.getMerges();
+    if (merges.some((m) => rangesIntersect(m, r) && !rangeContainsRange(r, m))) return false;
+    this.applyTableChange(() => {
+      for (let row = r.startRow; row <= r.endRow; row++) {
+        const rowId = this.document.rows[row].id;
+        for (let col = r.startCol; col <= r.endCol; col++) {
+          if (row === r.startRow && col === r.startCol) continue;
+          delete this.document.cells[rowId]?.[this.document.columns[col].id];
+        }
+      }
+      this.table.merges = [...merges.filter((m) => !rangeContainsRange(r, m)), r];
+    }, { recalculate: true });
+    this.selectCell(r.startRow, r.startCol);
+    return true;
+  }
+  /** Removes every merge intersecting `range` (default: the selection). */
+  unmergeCells(range = this.selectedRange) {
+    if (!range) return false;
+    const merges = this.getMerges();
+    const remaining = merges.filter((m) => !rangesIntersect(m, range));
+    if (remaining.length === merges.length) return false;
+    this.applyTableChange(() => {
+      this.table.merges = remaining;
+    });
+    return true;
+  }
+  // --- Autofill ---
+  /**
+   * Fills `target` from `source` like dragging the fill handle. `target` is
+   * the extended range (source included) and must extend `source` down, up,
+   * right or left. Numbers and dates continue their series, text ending in a
+   * number counts up, other text repeats, and formulas are copied with
+   * their relative references shifted (`$` parts stay). Returns false when
+   * the ranges don't line up.
+   */
+  autofill(source, target) {
+    const s = normalizeRange(source);
+    const t = normalizeRange(target);
+    const direction = getFillDirection(s, t);
+    if (!direction || t.startRow < 0 || t.startCol < 0) return false;
+    if (s.endRow >= this.document.rows.length || s.endCol >= this.document.columns.length) return false;
+    const vertical = direction === "down" || direction === "up";
+    const forward = direction === "down" || direction === "right";
+    const sourceSteps = [];
+    const [sLo, sHi] = vertical ? [s.startRow, s.endRow] : [s.startCol, s.endCol];
+    for (let i = sLo; i <= sHi; i++) sourceSteps.push(i);
+    if (!forward) sourceSteps.reverse();
+    const fillSteps = [];
+    if (forward) for (let i = sHi + 1; i <= (vertical ? t.endRow : t.endCol); i++) fillSteps.push(i);
+    else for (let i = sLo - 1; i >= (vertical ? t.startRow : t.startCol); i--) fillSteps.push(i);
+    const [lLo, lHi] = vertical ? [s.startCol, s.endCol] : [s.startRow, s.endRow];
+    this.runBatch(() => {
+      this.growGrid(vertical ? Math.max(t.endRow, 0) : s.endRow, vertical ? s.endCol : Math.max(t.endCol, 0));
+      for (let line = lLo; line <= lHi; line++) {
+        const at = (step) => vertical ? { row: step, col: line } : { row: line, col: step };
+        const raws = sourceSteps.map((step) => {
+          const p = at(step);
+          return this.getCell(this.document.rows[p.row].id, this.document.columns[p.col].id).raw;
+        });
+        const hasFormula = raws.some((raw) => raw.startsWith("="));
+        const series = hasFormula ? null : fillSeries(raws, fillSteps.length);
+        fillSteps.forEach((step, i) => {
+          const p = at(step);
+          let raw;
+          if (series) {
+            raw = series[i];
+          } else {
+            const from = sourceSteps[i % sourceSteps.length];
+            raw = raws[i % raws.length];
+            if (raw.startsWith("=")) {
+              const delta = step - from;
+              raw = vertical ? offsetFormulaReferences(raw, delta, 0) : offsetFormulaReferences(raw, 0, delta);
+            }
+          }
+          this.setCellValue(this.document.rows[p.row].id, this.document.columns[p.col].id, raw);
+        });
+      }
+    });
+    this.selectRange(t);
+    return true;
+  }
+  // --- Categories (row groups) ---
+  /**
+   * Groups body rows by the value in `colId`, with optional per-group
+   * summaries (e.g. `[{ colId, aggregate: 'sum' }]`).
+   */
+  groupRowsBy(colId, summaries = []) {
+    if (!this.getColumn(colId)) return;
+    this.applyTableChange(() => {
+      this.table.grouping = { colId, summaries, collapsed: [] };
+    });
+  }
+  ungroupRows() {
+    if (!this.document.table?.grouping) return;
+    this.applyTableChange(() => {
+      delete this.table.grouping;
+    });
+  }
+  /** Sets (or with `null`, removes) the group summary for a column. */
+  setGroupSummary(colId, aggregate) {
+    const grouping = this.document.table?.grouping;
+    if (!grouping) return;
+    this.applyTableChange(() => {
+      const others = grouping.summaries.filter((s) => s.colId !== colId);
+      this.table.grouping = {
+        ...grouping,
+        summaries: aggregate ? [...others, { colId, aggregate }] : others
+      };
+    });
+  }
+  setGroupCollapsed(key, collapsed) {
+    const grouping = this.document.table?.grouping;
+    if (!grouping || grouping.collapsed.includes(key) === collapsed) return;
+    this.applyTableChange(() => {
+      this.table.grouping = {
+        ...grouping,
+        collapsed: collapsed ? [...grouping.collapsed, key] : grouping.collapsed.filter((k) => k !== key)
+      };
+    });
+  }
+  toggleGroupCollapsed(key) {
+    const grouping = this.document.table?.grouping;
+    if (!grouping) return;
+    this.setGroupCollapsed(key, !grouping.collapsed.includes(key));
+  }
+  /** The current row groups with their summaries (empty when not grouped). */
+  getGroups() {
+    return computeRowGroups(this.document, this.getCellValueAt);
+  }
+  // --- Transpose ---
+  /**
+   * Transposes `range` (default: the selection) in place around its top-left
+   * cell: rows become columns. Cells left uncovered are cleared, the grid
+   * grows if needed, and references follow the moved cells. Returns false
+   * for single cells or when merged cells are involved.
+   */
+  transposeRange(range = this.selectedRange) {
+    if (!range) return false;
+    const s = normalizeRange(range);
+    if (isSingleCellRange(s)) return false;
+    const height = s.endRow - s.startRow + 1;
+    const width = s.endCol - s.startCol + 1;
+    const t = { startRow: s.startRow, startCol: s.startCol, endRow: s.startRow + width - 1, endCol: s.startCol + height - 1 };
+    if (this.getMerges().some((m) => rangesIntersect(m, s) || rangesIntersect(m, t))) return false;
+    this.applyTableChange(() => {
+      this.growGrid(t.endRow, t.endCol);
+      this.remapAllFormulas(({ row, col }) => {
+        if (!rangeContains(s, row, col)) return null;
+        return { row: s.startRow + (col - s.startCol), col: s.startCol + (row - s.startRow) };
+      });
+      const rowId = (r) => this.document.rows[r].id;
+      const colId = (c) => this.document.columns[c].id;
+      const moved = [];
+      for (let r = s.startRow; r <= s.endRow; r++) {
+        for (let c = s.startCol; c <= s.endCol; c++) {
+          moved.push({
+            row: s.startRow + (c - s.startCol),
+            col: s.startCol + (r - s.startRow),
+            cell: this.document.cells[rowId(r)]?.[colId(c)]
+          });
+          delete this.document.cells[rowId(r)]?.[colId(c)];
+        }
+      }
+      for (const { row, col, cell } of moved) {
+        if (!cell) continue;
+        if (!this.document.cells[rowId(row)]) this.document.cells[rowId(row)] = {};
+        this.document.cells[rowId(row)][colId(col)] = cell;
+      }
+    }, { recalculate: true });
+    this.selectRange(t);
+    return true;
+  }
+  // --- View model ---
+  /**
+   * What to render: visible rows (with group headers) and columns in display
+   * order, frozen offsets and merged-cell spans. Filters, hidden rows/columns
+   * and collapsed groups only affect this view, never the document.
+   */
+  getViewModel() {
+    return buildSpreadsheetView(this.document, this.getCellValueAt);
+  }
+  // --- Undo/Redo Snapshots ---
+  recordSnapshot() {
+    if (this.isApplyingHistory || this.batching) return;
+    this.undoStack.push(JSON.stringify(this.document));
+    if (this.undoStack.length > 50) this.undoStack.shift();
+    this.redoStack = [];
+  }
+  undo() {
+    if (this.undoStack.length === 0) return;
+    this.isApplyingHistory = true;
+    try {
+      this.redoStack.push(JSON.stringify(this.document));
+      this.document = JSON.parse(this.undoStack.pop());
+      this.recalculateAll();
+      this.notifyChange();
+    } finally {
+      this.isApplyingHistory = false;
+    }
+  }
+  redo() {
+    if (this.redoStack.length === 0) return;
+    this.isApplyingHistory = true;
+    try {
+      this.undoStack.push(JSON.stringify(this.document));
+      this.document = JSON.parse(this.redoStack.pop());
+      this.recalculateAll();
+      this.notifyChange();
+    } finally {
+      this.isApplyingHistory = false;
+    }
+  }
+  notifyChange() {
+    this.onDocumentChange?.(this.document);
+  }
+};
+function stepInOrder(order, from, delta) {
+  if (order.length === 0) return from;
+  const pos = order.indexOf(from);
+  if (pos === -1) {
+    const candidates = order.filter((i) => delta > 0 ? i > from : i < from);
+    if (candidates.length === 0) return from;
+    return candidates.reduce((best, i) => delta > 0 ? Math.min(best, i) : Math.max(best, i));
+  }
+  return order[Math.max(0, Math.min(order.length - 1, pos + delta))];
+}
+
+// src/spreadsheet/menu.ts
+var quote = (value) => {
+  const text = String(value ?? "");
+  return text.length > 24 ? `"${text.slice(0, 23)}\u2026"` : `"${text}"`;
+};
+function getSpreadsheetMenuItems(controller, cell) {
+  const doc = controller.document;
+  const column = doc.columns[cell.col];
+  const row = doc.rows[cell.row];
+  if (!column || !row) return [];
+  const selection = controller.selectedRange && rangeContains(controller.selectedRange, cell.row, cell.col) ? normalizeRange(controller.selectedRange) : { startRow: cell.row, startCol: cell.col, endRow: cell.row, endCol: cell.col };
+  const colName = indexToColName(cell.col);
+  const value = controller.getCell(row.id, column.id).value;
+  const table = doc.table ?? {};
+  const filter = controller.getFilterState();
+  const grouping = table.grouping;
+  const rows = Array.from({ length: selection.endRow - selection.startRow + 1 }, (_, i) => selection.startRow + i);
+  const cols = Array.from({ length: selection.endCol - selection.startCol + 1 }, (_, i) => selection.startCol + i);
+  const anyHidden = doc.rows.some((r) => r.hidden) || doc.columns.some((c) => c.hidden);
+  const hasMerge = controller.getMerges().some((m) => rangesIntersect(m, selection));
+  const sortRange = isSingleCellRange(selection) ? null : selection;
+  const items = [
+    {
+      id: "sort-asc",
+      label: `Sort ascending by column ${colName}`,
+      run: () => controller.sortRows([{ colId: column.id, direction: "asc" }], { range: sortRange })
+    },
+    {
+      id: "sort-desc",
+      label: `Sort descending by column ${colName}`,
+      run: () => controller.sortRows([{ colId: column.id, direction: "desc" }], { range: sortRange })
+    },
+    {
+      id: "filter-equals",
+      label: `Show only rows where ${colName} = ${quote(value)}`,
+      separatorBefore: true,
+      run: () => controller.addFilterRule({ colId: column.id, operator: "equals", value: String(value ?? "") })
+    },
+    {
+      id: "filter-toggle",
+      label: filter.enabled ? "Turn filters off" : "Turn filters on",
+      disabled: filter.rules.length === 0,
+      run: () => controller.toggleFilters()
+    },
+    {
+      id: "filter-clear",
+      label: "Clear filters",
+      disabled: filter.rules.length === 0,
+      run: () => controller.clearFilters()
+    },
+    {
+      id: "freeze-rows",
+      label: `Freeze rows 1\u2013${cell.row + 1}`,
+      separatorBefore: true,
+      run: () => controller.setFrozenRowCount(cell.row + 1)
+    },
+    {
+      id: "freeze-columns",
+      label: `Freeze columns A\u2013${colName}`,
+      run: () => controller.setFrozenColumnCount(cell.col + 1)
+    },
+    {
+      id: "unfreeze",
+      label: "Unfreeze rows and columns",
+      disabled: !table.frozenRowCount && !table.frozenColumnCount,
+      run: () => {
+        controller.setFrozenRowCount(0);
+        controller.setFrozenColumnCount(0);
+      }
+    },
+    {
+      id: "header-rows",
+      label: `Use rows 1\u2013${cell.row + 1} as header rows`,
+      run: () => controller.setHeaderRowCount(cell.row + 1)
+    },
+    {
+      id: "footer-rows",
+      label: `Use rows ${cell.row + 1}\u2013${doc.rows.length} as footer rows`,
+      run: () => controller.setFooterRowCount(doc.rows.length - cell.row)
+    },
+    {
+      id: "hide-rows",
+      label: rows.length > 1 ? `Hide ${rows.length} rows` : `Hide row ${cell.row + 1}`,
+      separatorBefore: true,
+      run: () => controller.hideRows(rows)
+    },
+    {
+      id: "hide-columns",
+      label: cols.length > 1 ? `Hide ${cols.length} columns` : `Hide column ${colName}`,
+      run: () => controller.hideColumns(cols)
+    },
+    {
+      id: "unhide-all",
+      label: "Unhide all rows and columns",
+      disabled: !anyHidden,
+      run: () => controller.unhideAll()
+    },
+    {
+      id: "merge",
+      label: "Merge cells",
+      separatorBefore: true,
+      disabled: isSingleCellRange(selection),
+      run: () => {
+        controller.mergeCells(selection);
+      }
+    },
+    {
+      id: "unmerge",
+      label: "Unmerge cells",
+      disabled: !hasMerge,
+      run: () => {
+        controller.unmergeCells(selection);
+      }
+    },
+    {
+      id: "transpose",
+      label: "Transpose",
+      disabled: isSingleCellRange(selection),
+      run: () => {
+        controller.transposeRange(selection);
+      }
+    }
+  ];
+  if (grouping) {
+    items.push(
+      {
+        id: "ungroup",
+        label: "Remove categories",
+        separatorBefore: true,
+        run: () => controller.ungroupRows()
+      },
+      ...["sum", "count", "average"].map((aggregate) => ({
+        id: `summary-${aggregate}`,
+        label: `Summarize column ${colName}: ${aggregate.toUpperCase()}`,
+        run: () => controller.setGroupSummary(column.id, aggregate)
+      }))
+    );
+  } else {
+    items.push({
+      id: "group-by",
+      label: `Categorize by column ${colName}`,
+      separatorBefore: true,
+      run: () => controller.groupRowsBy(column.id)
+    });
+  }
+  return items;
+}
+
+// src/spreadsheet/actions.ts
+var SPREADSHEET_TABLE_ACTIONS = [
+  "sortRows",
+  "getFilterState",
+  "setFilterRules",
+  "addFilterRule",
+  "updateFilterRule",
+  "removeFilterRule",
+  "clearFilters",
+  "setFiltersEnabled",
+  "toggleFilters",
+  "setHeaderRowCount",
+  "setFooterRowCount",
+  "setHeaderColumnCount",
+  "setFrozenRowCount",
+  "setFrozenColumnCount",
+  "hideRows",
+  "unhideRows",
+  "hideColumns",
+  "unhideColumns",
+  "unhideAll",
+  "getMerges",
+  "getMergeAt",
+  "mergeCells",
+  "unmergeCells",
+  "autofill",
+  "groupRowsBy",
+  "ungroupRows",
+  "setGroupSummary",
+  "setGroupCollapsed",
+  "toggleGroupCollapsed",
+  "getGroups",
+  "transposeRange",
+  "exportToCsv",
+  "importFromCsv",
+  "copyToClipboardData",
+  "pasteClipboardData"
+];
+function bindSpreadsheetTableActions(controller) {
+  const actions = {};
+  for (const name of SPREADSHEET_TABLE_ACTIONS) {
+    actions[name] = controller[name].bind(controller);
+  }
+  return actions;
+}
+
+// src/spreadsheet/import.ts
+function delimitedAdapter(id, label, delimiter, mimeTypes, extensions) {
+  return {
+    id,
+    label,
+    mimeTypes,
+    extensions,
+    target: "spreadsheet",
+    async import(_input, context) {
+      return { rows: parseCsv(await context.readText(), { delimiter }), delimiter };
+    }
+  };
+}
+var csvImportAdapter = delimitedAdapter(
+  "csv",
+  "CSV",
+  ",",
+  ["text/csv", "application/csv", "text/comma-separated-values"],
+  [".csv"]
+);
+var tsvImportAdapter = delimitedAdapter(
+  "tsv",
+  "Tab-separated values",
+  "	",
+  ["text/tab-separated-values"],
+  [".tsv", ".tab"]
+);
+var SPREADSHEET_IMPORT_ADAPTERS = [
+  csvImportAdapter,
+  tsvImportAdapter
+];
+function registerSpreadsheetImportAdapters(registry) {
+  const unregisters = SPREADSHEET_IMPORT_ADAPTERS.map(
+    (adapter) => registry.register(adapter, { replace: true })
+  );
+  return () => unregisters.forEach((unregister) => unregister());
+}
+async function importFileIntoSpreadsheet(controller, input, options) {
+  const { registry, startRow, startCol, ...rest } = options;
+  const outcome = await registry.importFile(input, { ...rest, target: "spreadsheet" });
+  controller.importRows(outcome.result.rows, { startRow, startCol });
+  return outcome;
+}
+
+export {
+  columnDependencyKey,
+  extractCellDependencies,
+  DependencyGraph,
+  shiftFormulaReferences,
+  mapFormulaReferences,
+  offsetFormulaReferences,
+  remapFormulaReferences,
+  getFormulaCaretContext,
+  getFormulaHints,
+  applyFormulaSuggestion,
+  DataSourceBinder,
+  normalizeRange,
+  rangeContains,
+  rangesIntersect,
+  rangeContainsRange,
+  isSingleCellRange,
+  isBlankValue,
+  toNumber,
+  compareCellValues,
+  matchesFilterRule,
+  aggregateValues,
+  roundFloat,
+  fillSeries,
+  computeFillTarget,
+  getFillDirection,
+  parseCsv,
+  escapeCsvField,
+  serializeCsv,
+  parseTsv,
+  serializeTsv,
+  SPREADSHEET_CLIPBOARD_MIME,
+  serializeHtmlTable,
+  parseHtmlTable,
+  createSpreadsheetClipboardData,
+  readSpreadsheetClipboard,
+  rebaseClipboardRows,
+  DEFAULT_ROW_HEIGHT,
+  DEFAULT_COLUMN_WIDTH,
+  getTableSections,
+  getRowSection,
+  rowPassesFilters,
+  computeRowGroups,
+  buildSpreadsheetView,
+  SpreadsheetController,
+  getSpreadsheetMenuItems,
+  SPREADSHEET_TABLE_ACTIONS,
+  bindSpreadsheetTableActions,
+  csvImportAdapter,
+  tsvImportAdapter,
+  SPREADSHEET_IMPORT_ADAPTERS,
+  registerSpreadsheetImportAdapters,
+  importFileIntoSpreadsheet
+};
+//# sourceMappingURL=chunk-GVW4P7BG.js.map