@pixerate/editor 0.24.0 → 0.26.0

package/dist/chunk-U5KWZU4X.js

@@ -1,3223 +0,0 @@
-import {
-  parseCsv,
-  parseTsv,
-  serializeCsv,
-  serializeTsv
-} from "./chunk-664LQYFJ.js";
-import {
-  FormulaEvaluator,
-  NumberFormat,
-  WHOLE_COLUMN_END_ROW,
-  colNameToIndex,
-  compareValues,
-  describeFormulaError,
-  formatTextFunction,
-  getFormulaArgumentSpecIndex,
-  getFormulaFunction,
-  getFormulaSignature,
-  getFormulaSignatureParts,
-  indexToColName,
-  isBlank,
-  isFormulaError,
-  numericValue,
-  parseCellInput,
-  parseFormula,
-  parseIsoDate,
-  searchFormulaFunctions,
-  sortCompareValues,
-  toText,
-  tokenizeFormula
-} from "./chunk-3CN2WD3X.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 === "SpillRef") {
-      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();
-  // Dynamic-array edges, set by the controller after evaluating an anchor:
-  // spilled cells depend on their anchor, and a blocked (#SPILL!) anchor
-  // depends on the cells blocking it. Kept apart from formula dependencies,
-  // so re-entering a formula doesn't drop them.
-  spillDependencies = /* @__PURE__ */ new Map();
-  spillDependents = /* @__PURE__ */ new Map();
-  // anchor -> the edges it registered (so they can be replaced).
-  spillEdges = /* @__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();
-    this.spillDependencies.clear();
-    this.spillDependents.clear();
-    this.spillEdges.clear();
-  }
-  /**
-   * Records the dynamic-array edges of the anchor `anchorKey`, replacing its
-   * previous ones: every key in `spilledKeys` (cells holding its spilled
-   * values) depends on the anchor, and the anchor depends on every key in
-   * `blockingKeys` (cells that stop it spilling). Pass empty lists to remove
-   * the anchor's edges.
-   */
-  setSpillEdges(anchorKey, spilledKeys, blockingKeys = []) {
-    const anchor = anchorKey.toUpperCase();
-    for (const [from, to] of this.spillEdges.get(anchor) ?? []) {
-      this.spillDependencies.get(from)?.delete(to);
-      this.spillDependents.get(to)?.delete(from);
-    }
-    const edges = [];
-    for (const key of spilledKeys) edges.push([key.toUpperCase(), anchor]);
-    for (const key of blockingKeys) edges.push([anchor, key.toUpperCase()]);
-    for (const [from, to] of edges) {
-      if (!this.spillDependencies.has(from)) this.spillDependencies.set(from, /* @__PURE__ */ new Set());
-      this.spillDependencies.get(from).add(to);
-      if (!this.spillDependents.has(to)) this.spillDependents.set(to, /* @__PURE__ */ new Set());
-      this.spillDependents.get(to).add(from);
-    }
-    if (edges.length > 0) this.spillEdges.set(anchor, edges);
-    else this.spillEdges.delete(anchor);
-  }
-  /** The spilled cells registered for `anchorKey` by `setSpillEdges`. */
-  getSpilledKeys(anchorKey) {
-    const anchor = anchorKey.toUpperCase();
-    return (this.spillEdges.get(anchor) ?? []).filter(([, to]) => to === anchor).map(([from]) => from);
-  }
-  /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
-  getDependencies(cellKey) {
-    const key = cellKey.toUpperCase();
-    return unionOf(this.dependencies.get(key), this.spillDependencies.get(key));
-  }
-  /** Cells depending on `cellKey`, through formulas or spills. */
-  getDependents(cellKey) {
-    const key = cellKey.toUpperCase();
-    return unionOf(this.dependents.get(key), this.spillDependents.get(key));
-  }
-  /**
-   * 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.getDependencies(node);
-      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.spillDependents.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.getDependencies(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 };
-  }
-};
-function unionOf(a, b) {
-  if (!b || b.size === 0) return Array.from(a ?? []);
-  if (!a || a.size === 0) return Array.from(b);
-  return Array.from(/* @__PURE__ */ new Set([...a, ...b]));
-}
-
-// 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" && token.type !== "SPILL_REF") 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);
-    if (token.type === "SPILL_REF") {
-      const rewritten = rewrite(original);
-      result += formula.slice(cursor, token.position) + (rewritten === "#REF!" ? rewritten : `${rewritten}#`);
-      cursor = end + 1;
-      continue;
-    }
-    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/numfmt/presets.ts
-var NUMBER_FORMAT_PRESETS = [
-  { id: "general", label: "General", code: "General" },
-  { id: "number", label: "Number (0.00)", code: "0.00" },
-  { id: "currency", label: "Currency ($1,234.50)", code: '"$"#,##0.00' },
-  { id: "percent", label: "Percent (12.5%)", code: "0.0%" },
-  { id: "date", label: "Date (3/14/2026)", code: "m/d/yyyy" },
-  { id: "time", label: "Time (1:30 PM)", code: "h:mm AM/PM" }
-];
-function numberFormatForCellFormat(format) {
-  switch (format) {
-    case "currency":
-      return '"$"#,##0.00';
-    case "percentage":
-      return "0%";
-    case "date":
-      return "m/d/yyyy";
-    default:
-      return void 0;
-  }
-}
-function cellFormatForNumberFormat(code) {
-  switch (NumberFormat.parseCached(code).kind()) {
-    case "number":
-    case "fraction":
-    case "scientific":
-    case "special":
-      return "number";
-    case "currency":
-    case "accounting":
-      return "currency";
-    case "percentage":
-      return "percentage";
-    case "date":
-      return "date";
-    case "text":
-      return "text";
-    default:
-      return void 0;
-  }
-}
-var isGeneralNumberFormat = (code) => code === void 0 || NumberFormat.parseCached(code).isGeneral();
-
-// src/spreadsheet/formula/format.ts
-function formatCellForDisplay(cell) {
-  if (!cell) return { text: "", numeric: false };
-  if (cell.error) return { text: cell.error, numeric: false };
-  const { value } = cell;
-  const code = cell.numberFormat ?? (typeof value === "number" ? numberFormatForCellFormat(cell.format) : void 0);
-  if (code !== void 0 && !isGeneralNumberFormat(code) && !isBlank(value) && typeof value !== "boolean") {
-    return NumberFormat.parseCached(code).format(value);
-  }
-  return { text: toText(value), numeric: typeof value === "number" };
-}
-function formatCellDisplay(cell) {
-  return formatCellForDisplay(cell).text;
-}
-function formatValueWithCode(value, format) {
-  const result = formatTextFunction(value, format);
-  return "text" in result ? result.text : null;
-}
-
-// 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;
-  let result;
-  if (isPlainText(a) && isPlainText(b) && !(parseIsoDate(a) && parseIsoDate(b))) {
-    result = compareText(a, b);
-  } else {
-    result = sortCompareValues(a, b);
-  }
-  if (result === 0) return 0;
-  return direction === "desc" ? -Math.sign(result) : Math.sign(result);
-}
-var isPlainText = (value) => typeof value === "string" && !isFormulaError(value);
-function filterValue(value) {
-  if (isBlankValue(value) || isFormulaError(value)) return null;
-  if (typeof value === "number") return Number.isFinite(value) ? { value, kind: "number" } : null;
-  if (typeof value === "boolean") return { value, kind: "boolean" };
-  const num = numericValue(value);
-  if (num !== null) return { value: num, kind: "number" };
-  const text = String(value);
-  return { value: text, kind: parseIsoDate(text) ? "number" : "text" };
-}
-function filterOperand(operand) {
-  if (typeof operand !== "string") return filterValue(operand);
-  if (operand.trim() === "") return null;
-  const parsed = parseCellInput(operand.trim());
-  if (parsed.type === "number" || parsed.type === "date" || parsed.type === "boolean") return filterValue(parsed.value);
-  return { value: operand, kind: "text" };
-}
-function compareForFilter(value, operand) {
-  const a = filterValue(value);
-  const b = filterOperand(operand);
-  if (!a || !b || a.kind !== b.kind) return null;
-  return compareValues(a.value, b.value);
-}
-function looselyEquals(value, operand) {
-  const c = compareForFilter(value, operand);
-  if (c !== null) return c === 0;
-  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 typed = parseCellInput(raw);
-  const date = ISO_DATE_PATTERN.exec(typed.type === "date" ? String(typed.value) : 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/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 texts = cells.map((row) => row.map((cell) => cell.text ?? displayText(cell.value)));
-  const payload = {
-    type: "pixerate-spreadsheet",
-    version: 1,
-    origin,
-    cells: cells.map((row) => row.map(({ raw, value }) => ({ raw, value })))
-  };
-  return {
-    "text/plain": serializeTsv(texts),
-    "text/html": serializeHtmlTable(texts),
-    [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 DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
-var MAX_SPILL_PASSES = 25;
-var spillCellId = (rowId, colId) => `${rowId}\0${colId}`;
-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;
-  maxHistoryBytes;
-  // 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;
-  // Cell being evaluated, for implicit intersection (`=@A:A`).
-  evaluatingCell = null;
-  // Dynamic arrays. Spilled values are derived state: they live here, not in
-  // the document, and every recalculation rebuilds them.
-  spills = /* @__PURE__ */ new Map();
-  // anchor key -> spill
-  spilledBy = /* @__PURE__ */ new Map();
-  // spilled cell key -> anchor key
-  spillCells = /* @__PURE__ */ new Map();
-  // spillCellId -> displayed cell
-  // Cells whose spill ownership changed during the current pass.
-  spillChanges = 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.maxHistoryBytes = Math.max(0, options.maxHistoryBytes ?? DEFAULT_MAX_HISTORY_BYTES);
-    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),
-      resolveSpill: (colStr, rowNum) => this.resolveSpillByCoord(colStr, rowNum),
-      getFormulaCell: () => this.evaluatingCell
-    });
-    this.syncWithDataSource();
-    this.rederiveTypedValues();
-    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.rederiveTypedValues();
-    this.recalculateAll();
-    this.notifyChange();
-  }
-  /**
-   * Re-parses the value of every stored typed (non-formula) cell from its
-   * `raw` input, so documents saved before typed input was parsed (whose
-   * values are text such as `"120"`) compare and sort as numbers. Cells of
-   * bound columns in record rows keep their value: it belongs to the data
-   * source.
-   */
-  rederiveTypedValues() {
-    for (const row of this.document.rows) {
-      const cells = this.document.cells[row.id];
-      if (!cells) continue;
-      for (const col of this.document.columns) {
-        const cell = cells[col.id];
-        if (!cell || typeof cell.raw !== "string" || cell.raw.startsWith("=")) continue;
-        if (col.type === "bound" && col.binding && row.recordId) continue;
-        const typed = this.typedCell(cell.raw, cell.format, col, cell);
-        cell.value = typed.value;
-        if (typed.numberFormat) cell.numberFormat = typed.numberFormat;
-        else delete cell.numberFormat;
-        if (typed.format) cell.format = typed.format;
-      }
-    }
-  }
-  /**
-   * Value of typed (non-formula) input: a number, boolean, ISO date, error
-   * or text (see `parseCellInput`), its automatic number format, and the
-   * `CellFormat` to use: the automatic one (currency, percentage, date,
-   * number) when `format` is unset or `text` (the default of new columns).
-   */
-  typedCell(raw, format, col, existing) {
-    const parsed = parseCellInput(raw);
-    const fixed = this.fixedNumberFormat(col, existing);
-    const numberFormat = fixed ?? parsed.numberFormat;
-    return {
-      value: parsed.value,
-      ...numberFormat ? { numberFormat } : {},
-      ...existing?.explicitNumberFormat ? { explicitNumberFormat: true } : {},
-      format: fixed === void 0 && parsed.cellFormat && (!format || format === "text") ? parsed.cellFormat : format
-    };
-  }
-  /**
-   * The number format a cell keeps whatever is typed into it: its explicit
-   * one, else its column's. Undefined lets typed input choose one.
-   */
-  fixedNumberFormat(col, existing) {
-    if (existing?.explicitNumberFormat && existing.numberFormat !== void 0) return existing.numberFormat;
-    return col?.numberFormat && !isGeneralNumberFormat(col.numberFormat) ? col.numberFormat : void 0;
-  }
-  /** `numberFormat` / `explicitNumberFormat` fields for a formula, bound or spilled cell. */
-  fixedNumberFormatFields(col, existing) {
-    const numberFormat = this.fixedNumberFormat(col, existing);
-    if (numberFormat === void 0) return {};
-    return existing?.explicitNumberFormat ? { numberFormat, explicitNumberFormat: true } : { numberFormat };
-  }
-  /**
-   * Typed input for a bound field, coerced by the field's declared type:
-   * number, boolean and date fields get a number, boolean or ISO date when
-   * the input parses as one; string and enum fields (and unknown fields)
-   * keep the text exactly as typed.
-   */
-  boundInputValue(dataSourceId, field, raw) {
-    if (raw.startsWith("=")) return raw;
-    const type = this.binder.getDataSource(dataSourceId)?.getFields().find((f) => f.key === field)?.type;
-    if (type !== "number" && type !== "boolean" && type !== "date") return raw;
-    const parsed = parseCellInput(raw);
-    if (type === "number" && parsed.type === "number") return parsed.value;
-    if (type === "boolean" && parsed.type === "boolean") return parsed.value;
-    if (type === "date" && parsed.type === "date") return parsed.value;
-    return raw;
-  }
-  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 && existing.raw !== "") return existing;
-    if (this.spillCells.size > 0) {
-      const spilled = this.spillCells.get(spillCellId(rowId, colId));
-      if (spilled) return spilled;
-    }
-    if (existing && !existing.explicitNumberFormat) return existing;
-    const col = this.document.columns.find((c) => c.id === colId);
-    const row = this.document.rows.find((r) => r.id === rowId);
-    const derived = this.getDerivedCell(row, col);
-    if (!existing) return derived;
-    if (derived.raw === "") return existing;
-    return { ...derived, numberFormat: existing.numberFormat, explicitNumberFormat: true };
-  }
-  /** 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,
-        ...this.fixedNumberFormatFields(col, void 0)
-      };
-    }
-    if (col && col.type === "formula" && col.formula) {
-      return {
-        raw: col.formula,
-        value: "",
-        format: col.format,
-        ...this.fixedNumberFormatFields(col, void 0)
-      };
-    }
-    return { raw: "", value: "", format: col?.format, ...this.fixedNumberFormatFields(col, void 0) };
-  }
-  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);
-    const isFormula = raw.startsWith("=");
-    const existing = this.document.cells[rowId][colId];
-    let cell;
-    if (col?.type === "bound" && col.binding && row?.recordId) {
-      const value = this.boundInputValue(col.binding.dataSource, col.binding.field, raw);
-      this.binder.commitBoundValue(col.binding.dataSource, row.recordId, col.binding.field, value);
-      cell = { raw, value, format: col.format, ...this.fixedNumberFormatFields(col, existing) };
-    } else if (isFormula) {
-      cell = { raw, value: raw, format: col?.format, ...this.fixedNumberFormatFields(col, existing) };
-    } else {
-      cell = { raw, ...this.typedCell(raw, col?.format, col, existing) };
-    }
-    const cellKey = this.getCellKey(rowId, colId);
-    this.depGraph.setCellFormula(cellKey, isFormula ? raw : null);
-    this.document.cells[rowId][colId] = cell;
-    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);
-    const anchor = this.spilledBy.get(cellKey);
-    this.recalculateKeys(anchor ? [cellKey, anchor] : [cellKey], true);
-  }
-  /**
-   * Recalculates `keys` (and, with `includeDependents`, their dependents) in
-   * dependency order. Spill ranges are only known after evaluating their
-   * anchors, so when a pass changes which cells hold spilled values (and so
-   * the dependency graph), the dependents of those cells are recalculated in
-   * another pass, until nothing changes.
-   */
-  recalculateKeys(keys, includeDependents) {
-    let pending = Array.from(keys);
-    let withDependents = includeDependents;
-    for (let pass = 0; pass < MAX_SPILL_PASSES && pending.length > 0; pass++) {
-      const changed = /* @__PURE__ */ new Set();
-      this.spillChanges = changed;
-      try {
-        this.runEvaluationPlan(this.depGraph.getEvaluationPlan(pending, { includeDependents: withDependents }));
-      } finally {
-        this.spillChanges = null;
-      }
-      pending = Array.from(changed);
-      withDependents = true;
-    }
-  }
-  /**
-   * Rebuilds the dependency graph from scratch and recalculates every formula
-   * in dependency order.
-   */
-  recalculateAll() {
-    this.depGraph.clear();
-    this.spills.clear();
-    this.spilledBy.clear();
-    this.spillCells.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.recalculateKeys(formulaKeys, false);
-  }
-  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 spilledKeys = this.depGraph.getSpilledKeys(cellKey);
-    const ownSpill = deps.find((dep) => spilledKeys.includes(dep));
-    const errorMessage = selfReference ? "This formula can't reference its own cell." : ownSpill ? `This formula refers to ${ownSpill}, which holds its own spilled results (a circular reference).` : "This formula is part of a circular reference: it depends on its own result through other cells.";
-    this.clearSpill(cellKey.toUpperCase(), true);
-    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;
-      }
-      this.clearSpill(`${colName}${rowNum}`);
-      return;
-    }
-    try {
-      this.evaluatingRowIndex = rowNum - 1;
-      this.evaluatingCell = { col: colName, row: rowNum };
-      const result = this.evaluator.evaluateWithDiagnostics(cell.raw);
-      if (!this.document.cells[row.id]) {
-        this.document.cells[row.id] = {};
-      }
-      let { value, error, message } = result;
-      if (result.array) {
-        const blocked = this.placeSpill(`${colName}${rowNum}`, rowNum - 1, this.document.columns.indexOf(col), result.array);
-        if (blocked) {
-          value = "#SPILL!";
-          error = "#SPILL!";
-          message = blocked;
-        }
-      } else {
-        this.clearSpill(`${colName}${rowNum}`);
-      }
-      this.document.cells[row.id][col.id] = {
-        ...cell,
-        value,
-        // `#ERROR!` (malformed formula, wrong argument count) keeps its
-        // message in `error`, as before; other errors store their code.
-        error: error === "#ERROR!" ? message : error,
-        errorMessage: message
-      };
-    } finally {
-      this.evaluatingRowIndex = null;
-      this.evaluatingCell = null;
-    }
-  }
-  // --- Dynamic arrays (spilling) ---
-  /**
-   * Spills `array` from the anchor at (row, col) into the cells below and to
-   * the right. Returns why it can't (the anchor then shows `#SPILL!`), or
-   * null once placed. The grid never grows to fit an array, as in Excel.
-   */
-  placeSpill(anchor, row, col, array) {
-    const { rows, cols } = array;
-    const area = { startRow: row, startCol: col, endRow: row + rows - 1, endCol: col + cols - 1 };
-    const label = `${indexToColName(area.startCol)}${area.startRow + 1}:${indexToColName(area.endCol)}${area.endRow + 1}`;
-    let reason = null;
-    const blockers = [];
-    if (area.endRow >= this.document.rows.length || area.endCol >= this.document.columns.length) {
-      reason = `The ${rows}\xD7${cols} result needs ${label}, which extends past the edge of the sheet.`;
-    } else if (this.getMerges().some((m) => rangesIntersect(m, area))) {
-      reason = `The result can't spill into merged cells (it needs ${label}).`;
-    } else {
-      for (let c = area.startCol; c <= area.endCol; c++) {
-        const column = this.document.columns[c];
-        for (let r = area.startRow; r <= area.endRow; r++) {
-          if (r === row && c === col) continue;
-          const rowObj = this.document.rows[r];
-          const key = `${column.key}${r + 1}`.toUpperCase();
-          const stored = this.document.cells[rowObj.id]?.[column.id];
-          const raw = stored ? stored.raw : this.getDerivedCell(rowObj, column).raw;
-          const owner = this.spilledBy.get(key);
-          if (raw !== "") {
-            blockers.push(key);
-            reason ??= `The result needs ${label}, but ${key} isn't empty.`;
-          } else if (owner && owner !== anchor) {
-            blockers.push(key);
-            reason ??= `The result needs ${label}, but ${key} already holds values spilled from ${owner}.`;
-          }
-        }
-      }
-    }
-    if (reason) {
-      this.clearSpill(anchor);
-      this.depGraph.setSpillEdges(anchor, [], blockers);
-      return reason;
-    }
-    const previous = this.spills.get(anchor);
-    const cells = [];
-    for (let c = 0; c < cols; c++) {
-      const column = this.document.columns[col + c];
-      for (let r = 0; r < rows; r++) {
-        if (r === 0 && c === 0) continue;
-        const rowObj = this.document.rows[row + r];
-        const key = `${column.key}${row + r + 1}`.toUpperCase();
-        const value = array.values[c * rows + r] ?? "";
-        const display = {
-          raw: "",
-          value,
-          format: column.format,
-          spillAnchor: anchor,
-          ...this.fixedNumberFormatFields(column, this.document.cells[rowObj.id]?.[column.id])
-        };
-        if (isFormulaError(value)) {
-          display.error = value;
-          display.errorMessage = describeFormulaError(value);
-        }
-        this.spillCells.set(spillCellId(rowObj.id, column.id), display);
-        if (this.spilledBy.get(key) !== anchor) {
-          this.spilledBy.set(key, anchor);
-          this.spillChanges?.add(key);
-        }
-        cells.push({ key, rowId: rowObj.id, colId: column.id });
-      }
-    }
-    if (previous) {
-      const kept = new Set(cells.map((cell) => cell.key));
-      for (const old of previous.cells) {
-        if (kept.has(old.key)) continue;
-        this.forgetSpilledCell(anchor, old);
-      }
-    }
-    this.spills.set(anchor, { anchor, row, col, rows, cols, values: array.values, cells });
-    this.depGraph.setSpillEdges(anchor, cells.map((cell) => cell.key));
-    return null;
-  }
-  /** Removes the array spilled from `anchor`. With `keepEdges`, its dependency edges stay. */
-  clearSpill(anchor, keepEdges = false) {
-    const record = this.spills.get(anchor);
-    if (record) {
-      for (const cell of record.cells) this.forgetSpilledCell(anchor, cell);
-      this.spills.delete(anchor);
-    }
-    if (!keepEdges) this.depGraph.setSpillEdges(anchor, []);
-  }
-  forgetSpilledCell(anchor, cell) {
-    if (this.spilledBy.get(cell.key) !== anchor) return;
-    this.spilledBy.delete(cell.key);
-    this.spillCells.delete(spillCellId(cell.rowId, cell.colId));
-    this.spillChanges?.add(cell.key);
-  }
-  resolveSpillByCoord(colStr, rowNum) {
-    const record = this.spills.get(`${colStr}${rowNum}`.toUpperCase());
-    if (record) return { rows: record.rows, cols: record.cols, values: record.values };
-    const value = this.resolveCellByCoord(colStr, rowNum);
-    return isFormulaError(value) ? value : "#REF!";
-  }
-  toSpill(record) {
-    const row = this.document.rows[record.row];
-    const col = this.document.columns[record.col];
-    return {
-      key: record.anchor,
-      anchor: { row: record.row, col: record.col },
-      range: {
-        startRow: record.row,
-        startCol: record.col,
-        endRow: record.row + record.rows - 1,
-        endCol: record.col + record.cols - 1
-      },
-      formula: row && col ? this.getCell(row.id, col.id).raw : ""
-    };
-  }
-  /**
-   * The dynamic array covering (row, col), whether it is the anchor (the cell
-   * holding the formula) or a spilled cell; null when there is none.
-   */
-  getSpillAt(row, col) {
-    if (this.spills.size === 0) return null;
-    const key = `${indexToColName(col)}${row + 1}`;
-    const record = this.spills.get(key) ?? this.spills.get(this.spilledBy.get(key) ?? "");
-    return record ? this.toSpill(record) : null;
-  }
-  /** Every dynamic array currently spilled. */
-  getSpills() {
-    return Array.from(this.spills.values(), (record) => this.toSpill(record));
-  }
-  /** Whether `range` overlaps a spilled array (its anchor or spilled cells). */
-  intersectsSpill(range) {
-    for (const record of this.spills.values()) {
-      const area = {
-        startRow: record.row,
-        startCol: record.col,
-        endRow: record.row + record.rows - 1,
-        endCol: record.col + record.cols - 1
-      };
-      if (rangesIntersect(area, range)) return true;
-    }
-    return false;
-  }
-  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",
-      ...config?.numberFormat ? { numberFormat: config.numberFormat } : {},
-      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 = formatCellDisplay(cell);
-      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) => {
-        return formatCellDisplay(this.getCell(row.id, col.id)).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 : formatCellDisplay(cell))
-    );
-    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) => {
-        const value = cell.error || cell.value;
-        const text = formatCellDisplay(cell);
-        if (cell.spillAnchor && !this.spillAnchorInRange(cell.spillAnchor, r)) {
-          return { raw: text, value, text };
-        }
-        return { raw: cell.raw, value, text };
-      })
-    );
-    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;
-  }
-  spillAnchorInRange(anchor, range) {
-    const record = this.spills.get(anchor);
-    return !!record && rangeContains(range, record.row, record.col);
-  }
-  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;
-    if (this.intersectsSpill(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;
-    });
-  }
-  // --- Number formats ---
-  //
-  // Cells are replaced, never mutated in place: framework bindings compare
-  // cell objects by identity to decide what to re-render.
-  /**
-   * Sets an explicit number format code (e.g. `0.00`, `"$"#,##0.00`,
-   * `m/d/yyyy`, `[Red]0;[Blue]-0`) on every cell in `range`, including blank
-   * cells, so values typed later keep it. `null` removes explicit formats: the
-   * cells go back to their column's format or the one chosen for typed input.
-   * Undoable as one step. Returns false when there is no range.
-   */
-  setCellNumberFormat(range, code) {
-    if (!range) return false;
-    const r = normalizeRange(range);
-    this.recordSnapshot();
-    const kind = code === null ? void 0 : cellFormatForNumberFormat(code);
-    for (let ri = r.startRow; ri <= r.endRow; ri++) {
-      const row = this.document.rows[ri];
-      if (!row) continue;
-      for (let ci = r.startCol; ci <= r.endCol; ci++) {
-        const col = this.document.columns[ci];
-        if (!col) continue;
-        const cells = this.document.cells[row.id] ??= {};
-        const existing = cells[col.id];
-        if (code === null) {
-          if (!existing?.explicitNumberFormat) continue;
-          if (existing.raw === "" && existing.value === "" && !existing.error) {
-            delete cells[col.id];
-          } else {
-            const { explicitNumberFormat: _explicit, ...rest } = existing;
-            cells[col.id] = this.withNumberFormat(rest, this.implicitNumberFormat(rest, col, row));
-          }
-        } else {
-          cells[col.id] = {
-            ...existing ?? { raw: "", value: "" },
-            format: kind ?? existing?.format ?? col.format,
-            numberFormat: code,
-            explicitNumberFormat: true
-          };
-        }
-        this.refreshSpilledNumberFormat(row, col);
-      }
-    }
-    this.document.updatedAt = Date.now();
-    this.notifyChange();
-    return true;
-  }
-  /**
-   * Sets the number format code of a column (`null` or `General` clears it).
-   * Its cells without an explicit format of their own use it, including
-   * values typed later; when cleared they go back to the format chosen for
-   * typed input. Undoable.
-   */
-  setColumnNumberFormat(colId, code) {
-    const col = this.getColumn(colId);
-    if (!col) return;
-    this.recordSnapshot();
-    if (code === null || isGeneralNumberFormat(code)) delete col.numberFormat;
-    else col.numberFormat = code;
-    for (const row of this.document.rows) {
-      const cells = this.document.cells[row.id];
-      const cell = cells?.[col.id];
-      if (cells && cell && !cell.explicitNumberFormat) {
-        cells[col.id] = this.withNumberFormat(cell, this.implicitNumberFormat(cell, col, row));
-      }
-      this.refreshSpilledNumberFormat(row, col);
-    }
-    this.document.updatedAt = Date.now();
-    this.notifyChange();
-  }
-  /** The column's format, or the one typed input chose (typed cells only). */
-  implicitNumberFormat(cell, col, row) {
-    const typed = cell.raw !== "" && !cell.raw.startsWith("=") && !(col.type === "bound" && col.binding && row.recordId);
-    return this.fixedNumberFormat(col, void 0) ?? (typed ? parseCellInput(cell.raw).numberFormat : void 0);
-  }
-  /** A copy of `cell` with `numberFormat` set, or removed when undefined. */
-  withNumberFormat(cell, numberFormat) {
-    const { numberFormat: _old, ...rest } = cell;
-    return numberFormat === void 0 ? rest : { ...rest, numberFormat };
-  }
-  /** Re-applies the stored cell's (or the column's) format to a spilled value shown there. */
-  refreshSpilledNumberFormat(row, col) {
-    const id = spillCellId(row.id, col.id);
-    const spilled = this.spillCells.get(id);
-    if (!spilled) return;
-    const { numberFormat: _old, explicitNumberFormat: _explicit, ...rest } = spilled;
-    this.spillCells.set(id, { ...rest, ...this.fixedNumberFormatFields(col, this.document.cells[row.id]?.[col.id]) });
-  }
-  // --- 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;
-    if (this.intersectsSpill(r)) 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;
-    }, { recalculate: true });
-    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;
-    if (this.intersectsSpill(s) || this.intersectsSpill(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 = [];
-    this.trimHistory();
-  }
-  /** Drops the oldest snapshots beyond `maxHistoryBytes`, always keeping the newest. */
-  trimHistory() {
-    if (this.maxHistoryBytes <= 0 || this.undoStack.length <= 1) return;
-    let total = 0;
-    for (const s of this.undoStack) total += s.length * 2;
-    for (const s of this.redoStack) total += s.length * 2;
-    while (total > this.maxHistoryBytes && this.undoStack.length > 1) {
-      total -= this.undoStack.shift().length * 2;
-    }
-  }
-  /** Approximate bytes held by the undo/redo snapshots (UTF-16 size). */
-  getHistoryByteSize() {
-    let total = 0;
-    for (const s of this.undoStack) total += s.length * 2;
-    for (const s of this.redoStack) total += s.length * 2;
-    return total;
-  }
-  /** Number of undo / redo snapshots currently held. */
-  getHistoryDepth() {
-    return { undo: this.undoStack.length, redo: this.redoStack.length };
-  }
-  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
-function runSpreadsheetMenuItem(item, ask) {
-  if (!item.input) {
-    item.run();
-    return true;
-  }
-  const prompt = ask ?? ((label, value) => typeof window !== "undefined" && window.prompt ? window.prompt(label, value) : null);
-  const text = prompt(item.input.label, item.input.defaultValue ?? "");
-  if (text === null || text === void 0) return false;
-  item.run(text);
-  return true;
-}
-function clampMenuPosition(point, size, viewport, margin = 4) {
-  const place = (start, length, limit) => {
-    if (start + length <= limit - margin) return Math.max(margin, start);
-    const flipped = start - length;
-    return Math.max(margin, flipped >= margin ? flipped : limit - margin - length);
-  };
-  return {
-    x: place(point.x, size.width, viewport.width),
-    y: place(point.y, size.height, viewport.height)
-  };
-}
-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 cellData = controller.getCell(row.id, column.id);
-  const value = cellData.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(formatCellDisplay(cellData))}`,
-      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);
-      }
-    }
-  ];
-  const currentFormat = cellData.numberFormat;
-  const presetMatch = NUMBER_FORMAT_PRESETS.find(
-    (p) => p.id === "general" ? isGeneralNumberFormat(currentFormat) : p.code === currentFormat
-  );
-  NUMBER_FORMAT_PRESETS.forEach((preset, i) => {
-    items.push({
-      id: `number-format-${preset.id}`,
-      label: `Format cells: ${preset.label}`,
-      separatorBefore: i === 0,
-      checked: presetMatch === preset,
-      run: () => {
-        controller.setCellNumberFormat(selection, preset.code);
-      }
-    });
-  });
-  items.push({
-    id: "number-format-custom",
-    label: "Format cells: Custom\u2026",
-    checked: !presetMatch,
-    input: { label: "Number format code, e.g. #,##0.00;[Red](#,##0.00)", defaultValue: currentFormat ?? "General" },
-    run: (code) => {
-      if (code === void 0) return;
-      controller.setCellNumberFormat(selection, code.trim() === "" ? null : code);
-    }
-  });
-  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",
-  "setCellNumberFormat",
-  "setColumnNumberFormat",
-  "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,
-  NUMBER_FORMAT_PRESETS,
-  numberFormatForCellFormat,
-  cellFormatForNumberFormat,
-  isGeneralNumberFormat,
-  formatCellForDisplay,
-  formatCellDisplay,
-  formatValueWithCode,
-  DataSourceBinder,
-  normalizeRange,
-  rangeContains,
-  rangesIntersect,
-  rangeContainsRange,
-  isSingleCellRange,
-  isBlankValue,
-  toNumber,
-  compareCellValues,
-  matchesFilterRule,
-  aggregateValues,
-  roundFloat,
-  fillSeries,
-  computeFillTarget,
-  getFillDirection,
-  SPREADSHEET_CLIPBOARD_MIME,
-  serializeHtmlTable,
-  parseHtmlTable,
-  createSpreadsheetClipboardData,
-  readSpreadsheetClipboard,
-  rebaseClipboardRows,
-  DEFAULT_ROW_HEIGHT,
-  DEFAULT_COLUMN_WIDTH,
-  getTableSections,
-  getRowSection,
-  rowPassesFilters,
-  computeRowGroups,
-  buildSpreadsheetView,
-  SpreadsheetController,
-  runSpreadsheetMenuItem,
-  clampMenuPosition,
-  getSpreadsheetMenuItems,
-  SPREADSHEET_TABLE_ACTIONS,
-  bindSpreadsheetTableActions,
-  csvImportAdapter,
-  tsvImportAdapter,
-  SPREADSHEET_IMPORT_ADAPTERS,
-  registerSpreadsheetImportAdapters,
-  importFileIntoSpreadsheet
-};
-//# sourceMappingURL=chunk-U5KWZU4X.js.map