@pixerate/editor 0.25.0 → 0.26.1

package/dist/{chunk-WSQKHXW7.cjs → chunk-NQF32I6Z.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } function _optionalChainDelete(ops) { const result = _optionalChain(ops); return result == null ? true : result; } var _class; var _class2; var _class3; var _class4;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } function _optionalChainDelete(ops) { const result = _optionalChain(ops); return result == null ? true : result; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
 
 
 
@@ -31,7 +31,7 @@ var _chunkTNNJXF46cjs = require('./chunk-TNNJXF46.cjs');
 
 
 
-var _chunkC7P22VIPcjs = require('./chunk-C7P22VIP.cjs');
+var _chunkEWCOFSCQcjs = require('./chunk-EWCOFSCQ.cjs');
 
 // src/spreadsheet/formula/dependency-graph.ts
 function extractNameDependencies(node) {
@@ -72,22 +72,22 @@ function extractCellDependencies(node) {
       deps.push({ col: curr.col, row: curr.row, ...sheet });
     } else if (curr.type === "SpillRef") {
       deps.push({ col: curr.col, row: curr.row, ...sheet });
-    } else if (curr.type === "Range" && curr.endRow >= _chunkC7P22VIPcjs.WHOLE_COLUMN_END_ROW) {
-      const startC = _chunkC7P22VIPcjs.colNameToIndex.call(void 0, curr.startCol);
-      const endC = _chunkC7P22VIPcjs.colNameToIndex.call(void 0, curr.endCol);
+    } else if (curr.type === "Range" && curr.endRow >= _chunkEWCOFSCQcjs.WHOLE_COLUMN_END_ROW) {
+      const startC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, curr.startCol);
+      const endC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, curr.endCol);
       for (let c = Math.min(startC, endC); c <= Math.max(startC, endC); c++) {
-        deps.push({ col: _chunkC7P22VIPcjs.indexToColName.call(void 0, c), row: 0, ...sheet });
+        deps.push({ col: _chunkEWCOFSCQcjs.indexToColName.call(void 0, c), row: 0, ...sheet });
       }
     } else if (curr.type === "Range") {
-      const startC = _chunkC7P22VIPcjs.colNameToIndex.call(void 0, curr.startCol);
-      const endC = _chunkC7P22VIPcjs.colNameToIndex.call(void 0, curr.endCol);
+      const startC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, curr.startCol);
+      const endC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, 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: _chunkC7P22VIPcjs.indexToColName.call(void 0, c), row: r, ...sheet });
+          deps.push({ col: _chunkEWCOFSCQcjs.indexToColName.call(void 0, c), row: r, ...sheet });
         }
       }
     } else if (curr.type === "BinaryOp") {
@@ -105,73 +105,325 @@ function extractCellDependencies(node) {
   visit(node);
   return deps;
 }
-var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this); }
-  // Map of cellKey (e.g. "B2") -> Set of cellKeys that this cell depends ON
-  __init() {this.dependencies = /* @__PURE__ */ new Map()}
-  // Map of cellKey (e.g. "A1") -> Set of cellKeys that depend ON this cell (dependents)
-  __init2() {this.dependents = /* @__PURE__ */ new Map()}
+function extractReferenceDependencies(node) {
+  const deps = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const curr = stack.pop();
+    const sheet = "sheet" in curr && curr.sheet !== void 0 ? "sheetEnd" in curr && curr.sheetEnd !== void 0 ? { sheet: curr.sheet, sheetEnd: curr.sheetEnd } : { sheet: curr.sheet } : {};
+    switch (curr.type) {
+      case "CellRef":
+      case "SpillRef":
+        deps.push({ kind: "cell", col: curr.col.toUpperCase(), row: curr.row, ...sheet });
+        break;
+      case "Range": {
+        const startC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, curr.startCol);
+        const endC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, curr.endCol);
+        const whole = curr.endRow >= _chunkEWCOFSCQcjs.WHOLE_COLUMN_END_ROW;
+        deps.push({
+          kind: "range",
+          startCol: _chunkEWCOFSCQcjs.indexToColName.call(void 0, Math.min(startC, endC)),
+          endCol: _chunkEWCOFSCQcjs.indexToColName.call(void 0, Math.max(startC, endC)),
+          startRow: whole ? 1 : Math.min(curr.startRow, curr.endRow),
+          endRow: whole ? _chunkEWCOFSCQcjs.WHOLE_COLUMN_END_ROW : Math.max(curr.startRow, curr.endRow),
+          ...sheet
+        });
+        break;
+      }
+      case "BinaryOp":
+        stack.push(curr.right, curr.left);
+        break;
+      case "UnaryOp":
+        stack.push(curr.argument);
+        break;
+      case "FunctionCall":
+        for (let i = curr.args.length - 1; i >= 0; i--) stack.push(curr.args[i]);
+        break;
+      case "Invoke":
+        for (let i = curr.args.length - 1; i >= 0; i--) stack.push(curr.args[i]);
+        stack.push(curr.callee);
+        break;
+      default:
+        break;
+    }
+  }
+  return deps;
+}
+function rangeDependencyKey(startCol, startRow, endCol, endRow, sheetPrefix = "") {
+  const prefix = sheetPrefix === "" ? "" : `${sheetPrefix}!`;
+  return `${prefix}${startCol}${startRow}:${endCol}${endRow}`.toUpperCase();
+}
+var WIDE_RANGE_COLUMNS = 64;
+var PENDING_INTERVALS = 32;
+var IntervalIndex = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this); }
+  __init() {this.items = []}
+  __init2() {this.dead = new Uint8Array(0)}
+  __init3() {this.deadCount = 0}
+  __init4() {this.maxEnd = new Float64Array(0)}
+  __init5() {this.leaves = 0}
+  __init6() {this.position = /* @__PURE__ */ new Map()}
+  __init7() {this.pending = /* @__PURE__ */ new Map()}
+  /** Live entries. */
+  get size() {
+    return this.items.length - this.deadCount + this.pending.size;
+  }
+  /** Adds (or revives) the entry `id`. An id always names the same interval. */
+  insert(r0, r1, id, payload) {
+    const at = this.position.get(id);
+    if (at !== void 0) {
+      if (this.dead[at]) {
+        this.dead[at] = 0;
+        this.deadCount--;
+        this.items[at].payload = payload;
+      }
+      return;
+    }
+    this.pending.set(id, { r0, r1, id, payload });
+  }
+  remove(id) {
+    const at = this.position.get(id);
+    if (at !== void 0) {
+      if (!this.dead[at]) {
+        this.dead[at] = 1;
+        this.deadCount++;
+      }
+      return;
+    }
+    this.pending.delete(id);
+  }
+  /** Merges pending insertions and drops dead entries when there are enough of them. */
+  settle() {
+    if (this.pending.size <= PENDING_INTERVALS && this.deadCount <= Math.max(this.items.length / 2, PENDING_INTERVALS)) return;
+    const all = [];
+    this.items.forEach((item, i) => {
+      if (!this.dead[i]) all.push(item);
+    });
+    for (const item of this.pending.values()) all.push(item);
+    all.sort((a, b) => a.r0 - b.r0 || a.r1 - b.r1 || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    let leaves = 1;
+    while (leaves < all.length) leaves *= 2;
+    const maxEnd = new Float64Array(2 * leaves).fill(-1);
+    all.forEach((item, i) => {
+      maxEnd[leaves + i] = item.r1;
+    });
+    for (let i = leaves - 1; i >= 1; i--) maxEnd[i] = Math.max(maxEnd[2 * i], maxEnd[2 * i + 1]);
+    this.items = all;
+    this.dead = new Uint8Array(all.length);
+    this.deadCount = 0;
+    this.maxEnd = maxEnd;
+    this.leaves = leaves;
+    this.position = new Map(all.map((item, i) => [item.id, i]));
+    this.pending = /* @__PURE__ */ new Map();
+  }
+  /** Calls `fn` for every live interval overlapping rows `a..b` (`r0 <= b && r1 >= a`). */
+  query(a, b, fn) {
+    this.settle();
+    for (const item of this.pending.values()) {
+      if (item.r0 <= b && item.r1 >= a) fn(item.payload, item);
+    }
+    let lo = 0;
+    let hi = this.items.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (this.items[mid].r0 <= b) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo === 0) return;
+    this.walk(1, 0, this.leaves, lo, a, fn);
+  }
+  walk(node, lo, hi, p, a, fn) {
+    if (lo >= p || this.maxEnd[node] < a) return;
+    if (hi - lo <= 1) {
+      const item = this.items[lo];
+      if (item && !this.dead[lo] && item.r1 >= a) fn(item.payload, item);
+      return;
+    }
+    const mid = lo + (hi - lo >>> 1);
+    this.walk(2 * node, lo, mid, p, a, fn);
+    this.walk(2 * node + 1, mid, hi, p, a, fn);
+  }
+}, _class);
+var CELL_KEY = /^([A-Z]+)(\d+)$/;
+var RANGE_KEY = /^([A-Z]+)(\d+):([A-Z]+)(\d+)$/;
+var COLUMN_KEY = /^([A-Z]+):$/;
+function parseKey(key) {
+  const bang = key.lastIndexOf("!");
+  const sheet = bang < 0 ? "" : key.slice(0, bang);
+  const ref = bang < 0 ? key : key.slice(bang + 1);
+  let m = CELL_KEY.exec(ref);
+  if (m) return { kind: "cell", sheet, col: _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, m[1]), row: Number(m[2]) };
+  m = RANGE_KEY.exec(ref);
+  if (m) {
+    const ca = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, m[1]);
+    const cb = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, m[3]);
+    const ra = Number(m[2]);
+    const rb = Number(m[4]);
+    return { kind: "range", sheet, c0: Math.min(ca, cb), c1: Math.max(ca, cb), r0: Math.min(ra, rb), r1: Math.max(ra, rb) };
+  }
+  m = COLUMN_KEY.exec(ref);
+  if (m) {
+    const c = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, m[1]);
+    return { kind: "range", sheet, c0: c, c1: c, r0: 1, r1: _chunkEWCOFSCQcjs.WHOLE_COLUMN_END_ROW };
+  }
+  return { kind: "opaque" };
+}
+var VIRTUAL_PREFIX = "\0";
+var DependencyGraph = (_class2 = class {constructor() { _class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this);_class2.prototype.__init13.call(this);_class2.prototype.__init14.call(this);_class2.prototype.__init15.call(this);_class2.prototype.__init16.call(this); }
+  // Formula cell -> what it reads (single cells and whole ranges).
+  __init8() {this.nodes = /* @__PURE__ */ new Map()}
+  // Cell -> formulas reading it as a single cell.
+  __init9() {this.cellDependents = /* @__PURE__ */ new Map()}
+  // Sheet ('' for unqualified keys) -> interval index of the ranges formulas read.
+  __init10() {this.rangeIndex = /* @__PURE__ */ new Map()}
+  // Formulas recalculated on every recalculation (NOW, RAND, …).
+  __init11() {this.volatile = /* @__PURE__ */ new Set()}
   // 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.
-  __init3() {this.spillDependencies = /* @__PURE__ */ new Map()}
-  __init4() {this.spillDependents = /* @__PURE__ */ new Map()}
+  __init12() {this.spillDependencies = /* @__PURE__ */ new Map()}
+  __init13() {this.spillDependents = /* @__PURE__ */ new Map()}
   // anchor -> the edges it registered (so they can be replaced).
-  __init5() {this.spillEdges = /* @__PURE__ */ new Map()}
+  __init14() {this.spillEdges = /* @__PURE__ */ new Map()}
+  // Blocked anchor -> its blockers. These edges only propagate changes
+  // (clearing a blocker recalculates the anchor): whether a cell blocks
+  // depends on its input, not its value, so they don't order evaluation and
+  // can't close a cycle.
+  __init15() {this.blockingEdges = /* @__PURE__ */ new Map()}
+  __init16() {this.parsed = /* @__PURE__ */ new Map()}
+  parse(key) {
+    let parsed = this.parsed.get(key);
+    if (!parsed) {
+      parsed = parseKey(key);
+      if (this.parsed.size > 2e5) this.parsed.clear();
+      this.parsed.set(key, parsed);
+    }
+    return parsed;
+  }
+  sheetIndex(sheet) {
+    let index = this.rangeIndex.get(sheet);
+    if (!index) {
+      index = { cols: /* @__PURE__ */ new Map(), wide: new IntervalIndex() };
+      this.rangeIndex.set(sheet, index);
+    }
+    return index;
+  }
+  removeNode(key) {
+    const node = this.nodes.get(key);
+    if (!node) return;
+    for (const dep of node.cells) {
+      const set = this.cellDependents.get(dep);
+      if (!set) continue;
+      set.delete(key);
+      if (set.size === 0) this.cellDependents.delete(dep);
+    }
+    for (const range of node.ranges) {
+      const index = this.rangeIndex.get(range.sheet);
+      if (!index) continue;
+      if (range.c1 - range.c0 + 1 > WIDE_RANGE_COLUMNS) {
+        index.wide.remove(`${range.r0}:${range.r1}:${range.c0}:${range.c1}:${key}`);
+      } else {
+        for (let c = range.c0; c <= range.c1; c++) _optionalChain([index, 'access', _2 => _2.cols, 'access', _3 => _3.get, 'call', _4 => _4(c), 'optionalAccess', _5 => _5.remove, 'call', _6 => _6(`${range.r0}:${range.r1}:${key}`)]);
+      }
+    }
+    this.nodes.delete(key);
+  }
   /**
-   * Sets the cells `cellKey` depends on directly (keys such as `B2`, or a
-   * column key from `columnDependencyKey`), replacing its previous
-   * dependencies. Used by spreadsheets whose keys carry more than A1 text
-   * (e.g. sheet-qualified keys); `setCellFormula` derives them from a formula.
+   * Sets what `cellKey` depends on directly, replacing its previous
+   * dependencies. Keys are single cells (`B2`), rectangles (`A1:B9`) or
+   * whole columns (`A:`, see `columnDependencyKey`), each optionally
+   * sheet-qualified (`SHEET!A1:A9`). Ranges are stored whole in an interval
+   * index, never expanded cell by cell. `setCellFormula` derives the keys
+   * from a formula.
    */
   setCellDependencies(cellKey2, dependencyKeys) {
     const key = cellKey2.toUpperCase();
-    for (const dep of _nullishCoalesce(this.dependencies.get(key), () => ( []))) {
-      _optionalChain([this, 'access', _2 => _2.dependents, 'access', _3 => _3.get, 'call', _4 => _4(dep), 'optionalAccess', _5 => _5.delete, 'call', _6 => _6(key)]);
-    }
-    this.dependencies.delete(key);
-    const deps = /* @__PURE__ */ new Set();
+    this.removeNode(key);
+    const node = { cells: /* @__PURE__ */ new Set(), ranges: [] };
+    const seenRanges = /* @__PURE__ */ new Set();
     for (const raw of dependencyKeys) {
       const dep = raw.toUpperCase();
-      deps.add(dep);
-      if (!this.dependents.has(dep)) this.dependents.set(dep, /* @__PURE__ */ new Set());
-      this.dependents.get(dep).add(key);
+      const parsed = this.parse(dep);
+      if (parsed.kind === "range" && !(parsed.c0 === parsed.c1 && parsed.r0 === parsed.r1)) {
+        if (seenRanges.has(dep)) continue;
+        seenRanges.add(dep);
+        node.ranges.push({ key: dep, sheet: parsed.sheet, c0: parsed.c0, c1: parsed.c1, r0: parsed.r0, r1: parsed.r1 });
+        continue;
+      }
+      const cell = parsed.kind === "range" ? `${parsed.sheet === "" ? "" : `${parsed.sheet}!`}${_chunkEWCOFSCQcjs.indexToColName.call(void 0, parsed.c0)}${parsed.r0}` : dep;
+      node.cells.add(cell);
     }
-    if (deps.size > 0) this.dependencies.set(key, deps);
+    if (node.cells.size === 0 && node.ranges.length === 0) {
+      this.volatile.delete(key);
+      return;
+    }
+    for (const dep of node.cells) {
+      let set = this.cellDependents.get(dep);
+      if (!set) this.cellDependents.set(dep, set = /* @__PURE__ */ new Set());
+      set.add(key);
+    }
+    for (const range of node.ranges) {
+      const index = this.sheetIndex(range.sheet);
+      if (range.c1 - range.c0 + 1 > WIDE_RANGE_COLUMNS) {
+        index.wide.insert(range.r0, range.r1, `${range.r0}:${range.r1}:${range.c0}:${range.c1}:${key}`, {
+          c0: range.c0,
+          c1: range.c1,
+          key
+        });
+      } else {
+        for (let c = range.c0; c <= range.c1; c++) {
+          let col = index.cols.get(c);
+          if (!col) index.cols.set(c, col = new IntervalIndex());
+          col.insert(range.r0, range.r1, `${range.r0}:${range.r1}:${key}`, key);
+        }
+      }
+    }
+    this.nodes.set(key, node);
+  }
+  /**
+   * Marks `cellKey` as volatile (its formula uses NOW, RAND, …): it is
+   * recalculated by every plan made with `includeVolatile`, whatever changed.
+   */
+  setVolatile(cellKey2, volatile) {
+    const key = cellKey2.toUpperCase();
+    if (volatile) this.volatile.add(key);
+    else this.volatile.delete(key);
+  }
+  /** Cells whose formulas are volatile. */
+  getVolatileKeys() {
+    return Array.from(this.volatile);
   }
   setCellFormula(cellKey2, formulaStr) {
     const key = cellKey2.toUpperCase();
-    const oldDeps = this.dependencies.get(key) || /* @__PURE__ */ new Set();
-    for (const dep of oldDeps) {
-      _optionalChain([this, 'access', _7 => _7.dependents, 'access', _8 => _8.get, 'call', _9 => _9(dep), 'optionalAccess', _10 => _10.delete, 'call', _11 => _11(key)]);
-    }
-    this.dependencies.delete(key);
     if (!formulaStr || !formulaStr.startsWith("=")) {
+      this.setCellDependencies(key, []);
       return;
     }
+    let ast;
     try {
-      const ast = _chunkC7P22VIPcjs.parseFormula.call(void 0, 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 (e) {
+      ast = _chunkEWCOFSCQcjs.parseFormula.call(void 0, formulaStr);
+    } catch (e2) {
+      this.setCellDependencies(key, []);
+      return;
+    }
+    const keys = [];
+    for (const dep of extractReferenceDependencies(ast)) {
+      keys.push(
+        dep.kind === "cell" ? `${dep.col}${dep.row}` : dep.endRow >= _chunkEWCOFSCQcjs.WHOLE_COLUMN_END_ROW && dep.startCol === dep.endCol ? columnDependencyKey(dep.startCol) : rangeDependencyKey(dep.startCol, dep.startRow, dep.endCol, dep.endRow)
+      );
     }
+    this.setCellDependencies(key, keys);
   }
   /** Removes every registered formula and dependency. */
   clear() {
-    this.dependencies.clear();
-    this.dependents.clear();
+    this.nodes.clear();
+    this.cellDependents.clear();
+    this.rangeIndex.clear();
+    this.volatile.clear();
     this.spillDependencies.clear();
     this.spillDependents.clear();
     this.spillEdges.clear();
+    this.blockingEdges.clear();
   }
   /**
    * Records the dynamic-array edges of the anchor `anchorKey`, replacing its
@@ -183,12 +435,18 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
   setSpillEdges(anchorKey, spilledKeys, blockingKeys = []) {
     const anchor = anchorKey.toUpperCase();
     for (const [from, to] of _nullishCoalesce(this.spillEdges.get(anchor), () => ( []))) {
-      _optionalChain([this, 'access', _12 => _12.spillDependencies, 'access', _13 => _13.get, 'call', _14 => _14(from), 'optionalAccess', _15 => _15.delete, 'call', _16 => _16(to)]);
-      _optionalChain([this, 'access', _17 => _17.spillDependents, 'access', _18 => _18.get, 'call', _19 => _19(to), 'optionalAccess', _20 => _20.delete, 'call', _21 => _21(from)]);
+      _optionalChain([this, 'access', _7 => _7.spillDependencies, 'access', _8 => _8.get, 'call', _9 => _9(from), 'optionalAccess', _10 => _10.delete, 'call', _11 => _11(to)]);
+      _optionalChain([this, 'access', _12 => _12.spillDependents, 'access', _13 => _13.get, 'call', _14 => _14(to), 'optionalAccess', _15 => _15.delete, 'call', _16 => _16(from)]);
     }
+    this.blockingEdges.delete(anchor);
     const edges = [];
     for (const key of spilledKeys) edges.push([key.toUpperCase(), anchor]);
-    for (const key of blockingKeys) edges.push([anchor, key.toUpperCase()]);
+    const blockers = /* @__PURE__ */ new Set();
+    for (const key of blockingKeys) {
+      edges.push([anchor, key.toUpperCase()]);
+      blockers.add(key.toUpperCase());
+    }
+    if (blockers.size > 0) this.blockingEdges.set(anchor, blockers);
     for (const [from, to] of edges) {
       if (!this.spillDependencies.has(from)) this.spillDependencies.set(from, /* @__PURE__ */ new Set());
       this.spillDependencies.get(from).add(to);
@@ -198,133 +456,201 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
     if (edges.length > 0) this.spillEdges.set(anchor, edges);
     else this.spillEdges.delete(anchor);
   }
+  /**
+   * Drops the edge from a spilled cell to the anchor whose values it holds,
+   * for a cell that just got input of its own: its value no longer comes
+   * from the anchor (which recalculates and becomes `#SPILL!`), and the
+   * stale edge could otherwise close a false cycle with the cell's new
+   * formula before the anchor is evaluated again.
+   */
+  detachSpilledCell(cellKey2) {
+    const key = cellKey2.toUpperCase();
+    const anchors = this.spillDependencies.get(key);
+    if (!anchors) return;
+    for (const anchor of Array.from(anchors)) {
+      if (_optionalChain([this, 'access', _17 => _17.blockingEdges, 'access', _18 => _18.get, 'call', _19 => _19(key), 'optionalAccess', _20 => _20.has, 'call', _21 => _21(anchor)])) continue;
+      const edges = this.spillEdges.get(anchor);
+      if (!_optionalChain([edges, 'optionalAccess', _22 => _22.some, 'call', _23 => _23(([from, to]) => from === key && to === anchor)])) continue;
+      anchors.delete(anchor);
+      _optionalChain([this, 'access', _24 => _24.spillDependents, 'access', _25 => _25.get, 'call', _26 => _26(anchor), 'optionalAccess', _27 => _27.delete, 'call', _28 => _28(key)]);
+      const kept = edges.filter(([from, to]) => !(from === key && to === anchor));
+      if (kept.length > 0) this.spillEdges.set(anchor, kept);
+      else this.spillEdges.delete(anchor);
+    }
+  }
   /** The spilled cells registered for `anchorKey` by `setSpillEdges`. */
   getSpilledKeys(anchorKey) {
     const anchor = anchorKey.toUpperCase();
     return (_nullishCoalesce(this.spillEdges.get(anchor), () => ( []))).filter(([, to]) => to === anchor).map(([from]) => from);
   }
-  /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
+  /**
+   * What a cell depends on directly: single cells, ranges (as registered,
+   * e.g. `A1:A9` or `A:`, not expanded) and dynamic-array (spill) edges.
+   */
   getDependencies(cellKey2) {
     const key = cellKey2.toUpperCase();
-    return unionOf(this.dependencies.get(key), this.spillDependencies.get(key));
+    const node = this.nodes.get(key);
+    const own = node ? [...node.cells, ...node.ranges.map((r) => r.key)] : [];
+    const spill = this.spillDependencies.get(key);
+    if (!spill || spill.size === 0) return own;
+    return Array.from(/* @__PURE__ */ new Set([...own, ...spill]));
+  }
+  /**
+   * Whether the formula in `formulaKey` reads `cellKey` directly: as a cell,
+   * inside one of its ranges, or through a spill edge.
+   */
+  dependsOn(formulaKey, cellKey2) {
+    const key = formulaKey.toUpperCase();
+    const target = cellKey2.toUpperCase();
+    if (_optionalChain([this, 'access', _29 => _29.spillDependencies, 'access', _30 => _30.get, 'call', _31 => _31(key), 'optionalAccess', _32 => _32.has, 'call', _33 => _33(target)])) return true;
+    const node = this.nodes.get(key);
+    if (!node) return false;
+    if (node.cells.has(target)) return true;
+    const parsed = this.parse(target);
+    if (parsed.kind !== "cell") return false;
+    return node.ranges.some(
+      (r) => r.sheet === parsed.sheet && parsed.col >= r.c0 && parsed.col <= r.c1 && parsed.row >= r.r0 && parsed.row <= r.r1
+    );
   }
-  /** Cells depending on `cellKey`, through formulas or spills. */
+  /**
+   * Formulas (and spilled cells) reading `cellKey` directly, through formulas
+   * or spills. Found in O(log n + k) through the range index.
+   */
   getDependents(cellKey2) {
-    const key = cellKey2.toUpperCase();
-    return unionOf(this.dependents.get(key), this.spillDependents.get(key));
+    const out = /* @__PURE__ */ new Set();
+    this.collectDependents(cellKey2.toUpperCase(), (key) => out.add(key));
+    return Array.from(out);
+  }
+  collectDependents(key, add) {
+    const cells = this.cellDependents.get(key);
+    if (cells) for (const dep of cells) add(dep);
+    const spill = this.spillDependents.get(key);
+    if (spill) for (const dep of spill) add(dep);
+    if (this.rangeIndex.size === 0) return;
+    const parsed = this.parse(key);
+    if (parsed.kind !== "cell") return;
+    const index = this.rangeIndex.get(parsed.sheet);
+    if (!index) return;
+    _optionalChain([index, 'access', _34 => _34.cols, 'access', _35 => _35.get, 'call', _36 => _36(parsed.col), 'optionalAccess', _37 => _37.query, 'call', _38 => _38(parsed.row, parsed.row, add)]);
+    if (index.wide.size > 0) {
+      index.wide.query(parsed.row, parsed.row, (wide) => {
+        if (parsed.col >= wide.c0 && parsed.col <= wide.c1) add(wide.key);
+      });
+    }
+  }
+  /** Sizes of the index: ranges count once (per column), not once per cell. */
+  getIndexStats() {
+    let cellEdges = 0;
+    let rangeEntries = 0;
+    for (const node of this.nodes.values()) {
+      cellEdges += node.cells.size;
+      for (const r of node.ranges) rangeEntries += r.c1 - r.c0 + 1 > WIDE_RANGE_COLUMNS ? 1 : r.c1 - r.c0 + 1;
+    }
+    return { formulas: this.nodes.size, cellEdges, rangeEntries, volatile: this.volatile.size };
   }
   /**
    * Detects if there is a cycle containing cellKey.
    */
   hasCycle(cellKey2) {
     const key = cellKey2.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);
+    return this.getEvaluationPlan([key], { includeDependents: true }).cyclic.has(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 };
+    const plan = this.getEvaluationPlan([startCellKey], { includeDependents: true });
+    return { order: plan.order, hasCycle: plan.cyclic.size > 0 };
   }
   /**
    * Plans a recalculation over `cellKeys` (and, with `includeDependents`, every
-   * cell that transitively depends on them). Returns the keys in evaluation
+   * cell that transitively depends on them; with `includeVolatile`, every
+   * volatile formula and its dependents too). 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.
+   *
+   * Only the planned cells are ordered: a range a formula reads becomes one
+   * node whose edges are the planned cells inside it (found by binary
+   * search), so a range shared by many formulas is resolved once.
    */
   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);
+    const visit = (key) => {
+      if (!nodes.has(key)) {
+        nodes.add(key);
+        queue.push(key);
       }
-    }
+    };
+    for (const key of cellKeys) visit(key.toUpperCase());
+    if (options.includeVolatile) for (const key of this.volatile) visit(key);
     if (options.includeDependents) {
-      while (queue.length > 0) {
-        const node = queue.pop();
-        const direct = [
-          ..._nullishCoalesce(this.dependents.get(node), () => ( [])),
-          ..._nullishCoalesce(this.spillDependents.get(node), () => ( [])),
-          ..._nullishCoalesce(this.dependents.get(columnDependencyKey(node.replace(/\d+$/, ""))), () => ( []))
-        ];
-        for (const dep of direct) {
-          if (!nodes.has(dep)) {
-            nodes.add(dep);
-            queue.push(dep);
+      while (queue.length > 0) this.collectDependents(queue.pop(), visit);
+    }
+    let positions = null;
+    const planPositions = () => {
+      if (positions) return positions;
+      positions = /* @__PURE__ */ new Map();
+      for (const key of nodes) {
+        const parsed = this.parse(key);
+        if (parsed.kind !== "cell") continue;
+        let sheet = positions.get(parsed.sheet);
+        if (!sheet) positions.set(parsed.sheet, sheet = /* @__PURE__ */ new Map());
+        let cells = sheet.get(parsed.col);
+        if (!cells) sheet.set(parsed.col, cells = []);
+        cells.push([parsed.row, key]);
+      }
+      for (const sheet of positions.values()) for (const cells of sheet.values()) cells.sort((a, b) => a[0] - b[0]);
+      return positions;
+    };
+    const rangeMembers = /* @__PURE__ */ new Map();
+    const rangeNode = (range) => {
+      const id = `${VIRTUAL_PREFIX}${range.sheet}!${range.c0}:${range.c1}:${range.r0}:${range.r1}`;
+      let members = rangeMembers.get(id);
+      if (!members) {
+        const found = [];
+        const sheet = planPositions().get(range.sheet);
+        const scan = (cells) => {
+          let lo = 0;
+          let hi = cells.length;
+          while (lo < hi) {
+            const mid = lo + hi >>> 1;
+            if (cells[mid][0] < range.r0) lo = mid + 1;
+            else hi = mid;
+          }
+          for (let i = lo; i < cells.length && cells[i][0] <= range.r1; i++) found.push(cells[i][1]);
+        };
+        if (sheet) {
+          if (range.c1 - range.c0 + 1 <= sheet.size) {
+            for (let c = range.c0; c <= range.c1; c++) {
+              const cells = sheet.get(c);
+              if (cells) scan(cells);
+            }
+          } else {
+            for (const [c, cells] of sheet) if (c >= range.c0 && c <= range.c1) scan(cells);
           }
         }
+        rangeMembers.set(id, members = found);
       }
-    }
+      return members.length > 0 ? id : null;
+    };
     const neighbors = (node) => {
+      if (node.startsWith(VIRTUAL_PREFIX)) return _nullishCoalesce(rangeMembers.get(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);
+      const formula = this.nodes.get(node);
+      if (formula) {
+        for (const dep of formula.cells) if (nodes.has(dep)) result.push(dep);
+        for (const range of formula.ranges) {
+          const id = rangeNode(range);
+          if (id) result.push(id);
         }
       }
+      const spill = this.spillDependencies.get(node);
+      if (spill) {
+        const blockers = this.blockingEdges.get(node);
+        for (const dep of spill) if (nodes.has(dep) && !_optionalChain([blockers, 'optionalAccess', _39 => _39.has, 'call', _40 => _40(dep)])) result.push(dep);
+      }
       return result;
     };
     const order = [];
@@ -372,6 +698,7 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
           } while (member !== frame.node);
           const isCycle = component.length > 1 || frame.edges.includes(frame.node);
           for (const key of component) {
+            if (key.startsWith(VIRTUAL_PREFIX)) continue;
             order.push(key);
             if (isCycle) cyclic.add(key);
           }
@@ -380,12 +707,7 @@ var DependencyGraph = (_class = class {constructor() { _class.prototype.__init.c
     }
     return { order, cyclic };
   }
-}, _class);
-function unionOf(a, b) {
-  if (!b || b.size === 0) return Array.from(_nullishCoalesce(a, () => ( [])));
-  if (!a || a.size === 0) return Array.from(b);
-  return Array.from(/* @__PURE__ */ new Set([...a, ...b]));
-}
+}, _class2);
 
 // src/spreadsheet/formula/references.ts
 var CELL_PART = /^(\$?)([A-Za-z]+)(\$?)(\d+)$/;
@@ -396,19 +718,19 @@ function parsePart(text) {
   if (cell) {
     return {
       colAbs: cell[1],
-      col: _chunkC7P22VIPcjs.colNameToIndex.call(void 0, cell[2]),
+      col: _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, cell[2]),
       rowAbs: cell[3],
       row: parseInt(cell[4], 10) - 1
     };
   }
   const column = COLUMN_PART.exec(text);
   if (column) {
-    return { colAbs: column[1], col: _chunkC7P22VIPcjs.colNameToIndex.call(void 0, column[2]), rowAbs: "", row: null };
+    return { colAbs: column[1], col: _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, column[2]), rowAbs: "", row: null };
   }
   return null;
 }
 function formatPart(part) {
-  const col = `${part.colAbs}${_chunkC7P22VIPcjs.indexToColName.call(void 0, part.col)}`;
+  const col = `${part.colAbs}${_chunkEWCOFSCQcjs.indexToColName.call(void 0, part.col)}`;
   return part.row === null ? col : `${col}${part.rowAbs}${part.row + 1}`;
 }
 function shiftCoordinate(value, change) {
@@ -458,8 +780,8 @@ function mapFormulaReferences(formula, rewrite) {
   if (!formula.startsWith("=")) return formula;
   let tokens;
   try {
-    tokens = _chunkC7P22VIPcjs.tokenizeFormula.call(void 0, formula);
-  } catch (e2) {
+    tokens = _chunkEWCOFSCQcjs.tokenizeFormula.call(void 0, formula);
+  } catch (e3) {
     return formula;
   }
   let result = "";
@@ -467,7 +789,7 @@ function mapFormulaReferences(formula, rewrite) {
   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 (_optionalChain([tokens, 'access', _22 => _22[i + 1], 'optionalAccess', _23 => _23.type]) === "LPAREN") continue;
+    if (_optionalChain([tokens, 'access', _41 => _41[i + 1], 'optionalAccess', _42 => _42.type]) === "LPAREN") continue;
     const refStart = _nullishCoalesce(token.refStart, () => ( token.position));
     let end = refStart;
     while (end < formula.length && REF_CHAR.test(formula[end])) end++;
@@ -566,8 +888,8 @@ function formatSheetPrefix(sheet, sheetEnd) {
 function tokensOf(formula) {
   if (!formula.startsWith("=")) return null;
   try {
-    return _chunkC7P22VIPcjs.tokenizeFormula.call(void 0, formula);
-  } catch (e3) {
+    return _chunkEWCOFSCQcjs.tokenizeFormula.call(void 0, formula);
+  } catch (e4) {
     return null;
   }
 }
@@ -631,7 +953,7 @@ function formulaIdentifiers(formula) {
   const out = [];
   tokens.forEach((token, i) => {
     if (token.type !== "IDENTIFIER") return;
-    const call = _optionalChain([tokens, 'access', _24 => _24[i + 1], 'optionalAccess', _25 => _25.type]) === "LPAREN";
+    const call = _optionalChain([tokens, 'access', _43 => _43[i + 1], 'optionalAccess', _44 => _44.type]) === "LPAREN";
     out.push(token.sheet === void 0 ? { name: token.value, call } : { name: token.value, sheet: token.sheet, call });
   });
   return out;
@@ -696,7 +1018,7 @@ function innermostCall(stack) {
 }
 var toSuggestion = (def) => ({
   name: def.name,
-  signature: _chunkC7P22VIPcjs.getFormulaSignature.call(void 0, def),
+  signature: _chunkEWCOFSCQcjs.getFormulaSignature.call(void 0, def),
   description: def.description,
   category: def.category
 });
@@ -715,21 +1037,21 @@ function getFormulaHints(input, caret = input.length, options = {}) {
     }));
     suggestions = [
       ...names,
-      ..._chunkC7P22VIPcjs.searchFormulaFunctions.call(void 0, query, { limit: void 0 }).filter((def) => def.name.startsWith(query) && !names.some((n) => n.name.toUpperCase() === def.name)).map(toSuggestion)
+      ..._chunkEWCOFSCQcjs.searchFormulaFunctions.call(void 0, query, { limit: void 0 }).filter((def) => def.name.startsWith(query) && !names.some((n) => n.name.toUpperCase() === def.name)).map(toSuggestion)
     ].slice(0, _nullishCoalesce(options.limit, () => ( 8)));
     const followedByParen = input.slice(context.prefix.end).trimStart().startsWith("(");
     if (followedByParen || suggestions.length === 1 && suggestions[0].name.toUpperCase() === query) suggestions = [];
   }
   let activeCall = null;
   if (context.call) {
-    const def = _chunkC7P22VIPcjs.getFormulaFunction.call(void 0, context.call.name);
+    const def = _chunkEWCOFSCQcjs.getFormulaFunction.call(void 0, context.call.name);
     if (def) {
-      const specIndex = _chunkC7P22VIPcjs.getFormulaArgumentSpecIndex.call(void 0, def, context.call.argIndex);
+      const specIndex = _chunkEWCOFSCQcjs.getFormulaArgumentSpecIndex.call(void 0, def, context.call.argIndex);
       activeCall = {
         name: def.name,
-        signature: _chunkC7P22VIPcjs.getFormulaSignature.call(void 0, def),
+        signature: _chunkEWCOFSCQcjs.getFormulaSignature.call(void 0, def),
         description: def.description,
-        parts: _chunkC7P22VIPcjs.getFormulaSignatureParts.call(void 0, def, context.call.argIndex),
+        parts: _chunkEWCOFSCQcjs.getFormulaSignatureParts.call(void 0, def, context.call.argIndex),
         argIndex: context.call.argIndex,
         argument: specIndex >= 0 ? def.args[specIndex] : null
       };
@@ -739,8 +1061,8 @@ function getFormulaHints(input, caret = input.length, options = {}) {
 }
 function applyFormulaSuggestion(input, caret, suggestion, options = {}) {
   const context = getFormulaCaretContext(input, caret);
-  const start = _nullishCoalesce(_optionalChain([context, 'access', _26 => _26.prefix, 'optionalAccess', _27 => _27.start]), () => ( caret));
-  const end = _nullishCoalesce(_optionalChain([context, 'access', _28 => _28.prefix, 'optionalAccess', _29 => _29.end]), () => ( caret));
+  const start = _nullishCoalesce(_optionalChain([context, 'access', _45 => _45.prefix, 'optionalAccess', _46 => _46.start]), () => ( caret));
+  const end = _nullishCoalesce(_optionalChain([context, 'access', _47 => _47.prefix, 'optionalAccess', _48 => _48.end]), () => ( caret));
   const definedName = typeof suggestion !== "string" && suggestion.kind === "name";
   const name = typeof suggestion === "string" ? suggestion : suggestion.name;
   const call = _nullishCoalesce(options.call, () => ( (definedName ? !!suggestion.isLambda : true)));
@@ -777,7 +1099,7 @@ function numberFormatForCellFormat(format) {
   }
 }
 function cellFormatForNumberFormat(code) {
-  switch (_chunkC7P22VIPcjs.NumberFormat.parseCached(code).kind()) {
+  switch (_chunkEWCOFSCQcjs.NumberFormat.parseCached(code).kind()) {
     case "number":
     case "fraction":
     case "scientific":
@@ -796,7 +1118,7 @@ function cellFormatForNumberFormat(code) {
       return void 0;
   }
 }
-var isGeneralNumberFormat = (code) => code === void 0 || _chunkC7P22VIPcjs.NumberFormat.parseCached(code).isGeneral();
+var isGeneralNumberFormat = (code) => code === void 0 || _chunkEWCOFSCQcjs.NumberFormat.parseCached(code).isGeneral();
 
 // src/spreadsheet/formula/format.ts
 function formatCellForDisplay(cell) {
@@ -804,22 +1126,22 @@ function formatCellForDisplay(cell) {
   if (cell.error) return { text: cell.error, numeric: false };
   const { value } = cell;
   const code = _nullishCoalesce(cell.numberFormat, () => ( (typeof value === "number" ? numberFormatForCellFormat(cell.format) : void 0)));
-  if (code !== void 0 && !isGeneralNumberFormat(code) && !_chunkC7P22VIPcjs.isBlank.call(void 0, value) && typeof value !== "boolean") {
-    return _chunkC7P22VIPcjs.NumberFormat.parseCached(code).format(value);
+  if (code !== void 0 && !isGeneralNumberFormat(code) && !_chunkEWCOFSCQcjs.isBlank.call(void 0, value) && typeof value !== "boolean") {
+    return _chunkEWCOFSCQcjs.NumberFormat.parseCached(code).format(value);
   }
-  return { text: _chunkC7P22VIPcjs.toText.call(void 0, value), numeric: typeof value === "number" };
+  return { text: _chunkEWCOFSCQcjs.toText.call(void 0, value), numeric: typeof value === "number" };
 }
 function formatCellDisplay(cell) {
   return formatCellForDisplay(cell).text;
 }
 function formatValueWithCode(value, format) {
-  const result = _chunkC7P22VIPcjs.formatTextFunction.call(void 0, value, format);
+  const result = _chunkEWCOFSCQcjs.formatTextFunction.call(void 0, value, format);
   return "text" in result ? result.text : null;
 }
 
 // src/spreadsheet/datasource/index.ts
-var DataSourceBinder = (_class2 = class {constructor() { _class2.prototype.__init6.call(this); }
-  __init6() {this.dataSources = /* @__PURE__ */ new Map()}
+var DataSourceBinder = (_class3 = class {constructor() { _class3.prototype.__init17.call(this); }
+  __init17() {this.dataSources = /* @__PURE__ */ new Map()}
   register(dataSource) {
     this.dataSources.set(dataSource.id, dataSource);
   }
@@ -850,10 +1172,10 @@ var DataSourceBinder = (_class2 = class {constructor() { _class2.prototype.__ini
     for (const record of records) {
       const existing = existingRecordRowMap.get(record.id);
       nextRows.push({
-        ..._optionalChain([existing, 'optionalAccess', _30 => _30.hidden]) ? { hidden: true } : {},
-        id: _optionalChain([existing, 'optionalAccess', _31 => _31.id]) || `row_${record.id}`,
+        ..._optionalChain([existing, 'optionalAccess', _49 => _49.hidden]) ? { hidden: true } : {},
+        id: _optionalChain([existing, 'optionalAccess', _50 => _50.id]) || `row_${record.id}`,
         index: rowIndex++,
-        height: _optionalChain([existing, 'optionalAccess', _32 => _32.height]) || 32,
+        height: _optionalChain([existing, 'optionalAccess', _51 => _51.height]) || 32,
         recordId: record.id,
         type: "record"
       });
@@ -885,7 +1207,7 @@ var DataSourceBinder = (_class2 = class {constructor() { _class2.prototype.__ini
     if (!ds) return;
     await ds.updateRecord(recordId, field, value);
   }
-}, _class2);
+}, _class3);
 
 // src/spreadsheet/workbook.ts
 var MAX_SHEET_NAME_LENGTH = 31;
@@ -991,28 +1313,28 @@ function compareCellValues(a, b, direction = "asc") {
   const bBlank = isBlankValue(b);
   if (aBlank || bBlank) return aBlank === bBlank ? 0 : aBlank ? 1 : -1;
   let result;
-  if (isPlainText(a) && isPlainText(b) && !(_chunkC7P22VIPcjs.parseIsoDate.call(void 0, a) && _chunkC7P22VIPcjs.parseIsoDate.call(void 0, b))) {
+  if (isPlainText(a) && isPlainText(b) && !(_chunkEWCOFSCQcjs.parseIsoDate.call(void 0, a) && _chunkEWCOFSCQcjs.parseIsoDate.call(void 0, b))) {
     result = compareText(a, b);
   } else {
-    result = _chunkC7P22VIPcjs.sortCompareValues.call(void 0, a, b);
+    result = _chunkEWCOFSCQcjs.sortCompareValues.call(void 0, a, b);
   }
   if (result === 0) return 0;
   return direction === "desc" ? -Math.sign(result) : Math.sign(result);
 }
-var isPlainText = (value) => typeof value === "string" && !_chunkC7P22VIPcjs.isFormulaError.call(void 0, value);
+var isPlainText = (value) => typeof value === "string" && !_chunkEWCOFSCQcjs.isFormulaError.call(void 0, value);
 function filterValue(value) {
-  if (isBlankValue(value) || _chunkC7P22VIPcjs.isFormulaError.call(void 0, value)) return null;
+  if (isBlankValue(value) || _chunkEWCOFSCQcjs.isFormulaError.call(void 0, 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 = _chunkC7P22VIPcjs.numericValue.call(void 0, value);
+  const num = _chunkEWCOFSCQcjs.numericValue.call(void 0, value);
   if (num !== null) return { value: num, kind: "number" };
   const text = String(value);
-  return { value: text, kind: _chunkC7P22VIPcjs.parseIsoDate.call(void 0, text) ? "number" : "text" };
+  return { value: text, kind: _chunkEWCOFSCQcjs.parseIsoDate.call(void 0, text) ? "number" : "text" };
 }
 function filterOperand(operand) {
   if (typeof operand !== "string") return filterValue(operand);
   if (operand.trim() === "") return null;
-  const parsed = _chunkC7P22VIPcjs.parseCellInput.call(void 0, operand.trim());
+  const parsed = _chunkEWCOFSCQcjs.parseCellInput.call(void 0, operand.trim());
   if (parsed.type === "number" || parsed.type === "date" || parsed.type === "boolean") return filterValue(parsed.value);
   return { value: operand, kind: "text" };
 }
@@ -1020,7 +1342,7 @@ function compareForFilter(value, operand) {
   const a = filterValue(value);
   const b = filterOperand(operand);
   if (!a || !b || a.kind !== b.kind) return null;
-  return _chunkC7P22VIPcjs.compareValues.call(void 0, a.value, b.value);
+  return _chunkEWCOFSCQcjs.compareValues.call(void 0, a.value, b.value);
 }
 function looselyEquals(value, operand) {
   const c = compareForFilter(value, operand);
@@ -1099,7 +1421,7 @@ function classifyFillValue(raw) {
   if (raw.trim() === "") return { kind: "blank" };
   const num = toNumber(raw);
   if (num !== null) return { kind: "number", value: num };
-  const typed = _chunkC7P22VIPcjs.parseCellInput.call(void 0, raw);
+  const typed = _chunkEWCOFSCQcjs.parseCellInput.call(void 0, 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])];
@@ -1271,8 +1593,8 @@ function parseHtmlTable(html) {
     while (cellMatch = cellPattern.exec(rowMatch[1])) {
       while (taken.has(col)) row[col++] = "";
       const attrs = _nullishCoalesce(cellMatch[2], () => ( ""));
-      const colspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/colspan\s*=\s*["']?(\d+)/i, 'access', _33 => _33.exec, 'call', _34 => _34(attrs), 'optionalAccess', _35 => _35[1]]), () => ( "1")), 10));
-      const rowspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/rowspan\s*=\s*["']?(\d+)/i, 'access', _36 => _36.exec, 'call', _37 => _37(attrs), 'optionalAccess', _38 => _38[1]]), () => ( "1")), 10));
+      const colspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/colspan\s*=\s*["']?(\d+)/i, 'access', _52 => _52.exec, 'call', _53 => _53(attrs), 'optionalAccess', _54 => _54[1]]), () => ( "1")), 10));
+      const rowspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/rowspan\s*=\s*["']?(\d+)/i, 'access', _55 => _55.exec, 'call', _56 => _56(attrs), 'optionalAccess', _57 => _57[1]]), () => ( "1")), 10));
       row[col] = cellHtmlToText(cellMatch[3]);
       for (let c = col; c < col + colspan; c++) {
         if (c > col) row[c] = "";
@@ -1309,18 +1631,18 @@ function readFormat(source, format) {
       return _nullishCoalesce(source.getData(format), () => ( ""));
     }
     return _nullishCoalesce(source[format], () => ( ""));
-  } catch (e4) {
+  } catch (e5) {
     return "";
   }
 }
 function parsePayload(json) {
   try {
     const payload = JSON.parse(json);
-    if (_optionalChain([payload, 'optionalAccess', _39 => _39.type]) !== "pixerate-spreadsheet" || !Array.isArray(payload.cells) || !payload.cells.every((row) => Array.isArray(row)) || typeof _optionalChain([payload, 'access', _40 => _40.origin, 'optionalAccess', _41 => _41.row]) !== "number" || typeof _optionalChain([payload, 'access', _42 => _42.origin, 'optionalAccess', _43 => _43.col]) !== "number") {
+    if (_optionalChain([payload, 'optionalAccess', _58 => _58.type]) !== "pixerate-spreadsheet" || !Array.isArray(payload.cells) || !payload.cells.every((row) => Array.isArray(row)) || typeof _optionalChain([payload, 'access', _59 => _59.origin, 'optionalAccess', _60 => _60.row]) !== "number" || typeof _optionalChain([payload, 'access', _61 => _61.origin, 'optionalAccess', _62 => _62.col]) !== "number") {
       return null;
     }
     return payload;
-  } catch (e5) {
+  } catch (e6) {
     return null;
   }
 }
@@ -1330,7 +1652,7 @@ function readSpreadsheetClipboard(source) {
     return {
       format: "internal",
       origin: payload.origin,
-      rows: payload.cells.map((row) => row.map((cell) => typeof _optionalChain([cell, 'optionalAccess', _44 => _44.raw]) === "string" ? cell.raw : displayText(_optionalChain([cell, 'optionalAccess', _45 => _45.value]))))
+      rows: payload.cells.map((row) => row.map((cell) => typeof _optionalChain([cell, 'optionalAccess', _63 => _63.raw]) === "string" ? cell.raw : displayText(_optionalChain([cell, 'optionalAccess', _64 => _64.value]))))
     };
   }
   const html = readFormat(source, "text/html");
@@ -1437,8 +1759,8 @@ function forEachRangeCell(ranges, rowCount, colCount, fn) {
 function formatRuleRanges(ranges) {
   return ranges.map((range) => {
     const r = normalizeRange(range);
-    const start = `${_chunkC7P22VIPcjs.indexToColName.call(void 0, r.startCol)}${r.startRow + 1}`;
-    const end = `${_chunkC7P22VIPcjs.indexToColName.call(void 0, r.endCol)}${r.endRow + 1}`;
+    const start = `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, r.startCol)}${r.startRow + 1}`;
+    const end = `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, r.endCol)}${r.endRow + 1}`;
     return start === end ? start : `${start}:${end}`;
   }).join(", ");
 }
@@ -1451,9 +1773,9 @@ function parseRuleRanges(text) {
     const m = A1_RANGE.exec(part);
     if (!m) return null;
     const startRow = Number(m[2]) - 1;
-    const startCol = _chunkC7P22VIPcjs.colNameToIndex.call(void 0, m[1]);
+    const startCol = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, m[1]);
     const endRow = m[4] ? Number(m[4]) - 1 : startRow;
-    const endCol = m[3] ? _chunkC7P22VIPcjs.colNameToIndex.call(void 0, m[3]) : startCol;
+    const endCol = m[3] ? _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, m[3]) : startCol;
     if (startRow < 0 || endRow < 0 || startCol < 0 || endCol < 0) return null;
     out.push(normalizeRange({ startRow, startCol, endRow, endCol }));
   }
@@ -1513,7 +1835,7 @@ function conditionalFormatNumber(value) {
   if (typeof value !== "string" || value.length < 8 || value.length > 19) return null;
   const m = ISO_DATE.exec(value);
   if (!m) return null;
-  const serial = _chunkC7P22VIPcjs.serialFromYmd.call(void 0, Number(m[1]), Number(m[2]), Number(m[3]));
+  const serial = _chunkEWCOFSCQcjs.serialFromYmd.call(void 0, Number(m[1]), Number(m[2]), Number(m[3]));
   if (serial === null) return null;
   const time = m[4] ? (Number(m[4]) * 3600 + Number(m[5]) * 60 + Number(_nullishCoalesce(m[6], () => ( 0)))) / 86400 : 0;
   return serial + time;
@@ -1521,7 +1843,7 @@ function conditionalFormatNumber(value) {
 function valueText(value) {
   if (isBlank2(value)) return "";
   if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  if (typeof value === "number") return _chunkC7P22VIPcjs.numberToText.call(void 0, value);
+  if (typeof value === "number") return _chunkEWCOFSCQcjs.numberToText.call(void 0, value);
   return String(value);
 }
 function firstValue(value) {
@@ -1565,9 +1887,9 @@ function usesFormulas(rule) {
     case "colorScale":
       return rule.stops.some((s) => s.value.type === "formula");
     case "dataBar":
-      return _optionalChain([rule, 'access', _46 => _46.min, 'optionalAccess', _47 => _47.type]) === "formula" || _optionalChain([rule, 'access', _48 => _48.max, 'optionalAccess', _49 => _49.type]) === "formula";
+      return _optionalChain([rule, 'access', _65 => _65.min, 'optionalAccess', _66 => _66.type]) === "formula" || _optionalChain([rule, 'access', _67 => _67.max, 'optionalAccess', _68 => _68.type]) === "formula";
     case "iconSet":
-      return !!_optionalChain([rule, 'access', _50 => _50.thresholds, 'optionalAccess', _51 => _51.some, 'call', _52 => _52((t) => t.type === "formula")]);
+      return !!_optionalChain([rule, 'access', _69 => _69.thresholds, 'optionalAccess', _70 => _70.some, 'call', _71 => _71((t) => t.type === "formula")]);
     default:
       return false;
   }
@@ -1602,15 +1924,15 @@ var Overlay = class {
   }
 };
 var EMPTY_CONDITIONAL_FORMAT_OVERLAY = new Overlay(/* @__PURE__ */ new Map());
-var ConditionalFormatEngine = (_class3 = class {
-  constructor(sheet) {;_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
+var ConditionalFormatEngine = (_class4 = class {
+  constructor(sheet) {;_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);
     this.sheet = sheet;
   }
   
-  __init7() {this.cells = /* @__PURE__ */ new Map()}
-  __init8() {this.stats = /* @__PURE__ */ new Map()}
-  __init9() {this.rulesKey = null}
-  __init10() {this.current = EMPTY_CONDITIONAL_FORMAT_OVERLAY}
+  __init18() {this.cells = /* @__PURE__ */ new Map()}
+  __init19() {this.stats = /* @__PURE__ */ new Map()}
+  __init20() {this.rulesKey = null}
+  __init21() {this.current = EMPTY_CONDITIONAL_FORMAT_OVERLAY}
   /** Replaces the sheet accessor (e.g. after rows or columns were added). */
   setSheet(sheet) {
     this.sheet = sheet;
@@ -1707,7 +2029,7 @@ var ConditionalFormatEngine = (_class3 = class {
     if (!this.sheet.evaluateFormula) return "#NAME?";
     try {
       return firstValue(this.sheet.evaluateFormula(ruleFormulaAt(formula, ruleAnchor(rule.ranges), row, col), row, col));
-    } catch (e6) {
+    } catch (e7) {
       return "#ERROR!";
     }
   }
@@ -1735,7 +2057,7 @@ var ConditionalFormatEngine = (_class3 = class {
   operand(text, rule, row, col) {
     if (text === void 0) return "";
     if (isFormulaText(text)) return this.evalFormula(text, rule, row, col);
-    return _chunkC7P22VIPcjs.parseCellInput.call(void 0, text).value;
+    return _chunkEWCOFSCQcjs.parseCellInput.call(void 0, text).value;
   }
   /** Combines every rule that applies to (row, col). */
   computeLook(rules, row, col) {
@@ -1767,7 +2089,7 @@ var ConditionalFormatEngine = (_class3 = class {
    * scale fill, bar or icon on `out`, or null.
    */
   matchRule(rule, v, row, col, out) {
-    const error = _chunkC7P22VIPcjs.isFormulaError.call(void 0, v);
+    const error = _chunkEWCOFSCQcjs.isFormulaError.call(void 0, v);
     switch (rule.type) {
       case "cellIs": {
         if (error) return null;
@@ -1775,18 +2097,18 @@ var ConditionalFormatEngine = (_class3 = class {
         let ok;
         if (rule.operator === "between" || rule.operator === "notBetween") {
           const b = this.operand(rule.value2, rule, row, col);
-          const [lo, hi] = _chunkC7P22VIPcjs.compareValues.call(void 0, a, b) > 0 ? [b, a] : [a, b];
-          const inside = _chunkC7P22VIPcjs.compareValues.call(void 0, v, lo) >= 0 && _chunkC7P22VIPcjs.compareValues.call(void 0, v, hi) <= 0;
+          const [lo, hi] = _chunkEWCOFSCQcjs.compareValues.call(void 0, a, b) > 0 ? [b, a] : [a, b];
+          const inside = _chunkEWCOFSCQcjs.compareValues.call(void 0, v, lo) >= 0 && _chunkEWCOFSCQcjs.compareValues.call(void 0, v, hi) <= 0;
           ok = rule.operator === "between" ? inside : !inside;
         } else {
-          if (_chunkC7P22VIPcjs.isFormulaError.call(void 0, a)) return null;
-          const cmp = _chunkC7P22VIPcjs.compareValues.call(void 0, v, a);
+          if (_chunkEWCOFSCQcjs.isFormulaError.call(void 0, a)) return null;
+          const cmp = _chunkEWCOFSCQcjs.compareValues.call(void 0, v, a);
           ok = rule.operator === "equal" ? cmp === 0 : rule.operator === "notEqual" ? cmp !== 0 : rule.operator === "greaterThan" ? cmp > 0 : rule.operator === "lessThan" ? cmp < 0 : rule.operator === "greaterThanOrEqual" ? cmp >= 0 : cmp <= 0;
         }
         return ok ? rule.style : null;
       }
       case "expression": {
-        const result = _chunkC7P22VIPcjs.toBoolean.call(void 0, this.evalFormula(rule.formula, rule, row, col));
+        const result = _chunkEWCOFSCQcjs.toBoolean.call(void 0, this.evalFormula(rule.formula, rule, row, col));
         return result === true ? rule.style : null;
       }
       case "containsText":
@@ -1833,7 +2155,7 @@ var ConditionalFormatEngine = (_class3 = class {
       case "timePeriod": {
         const n = conditionalFormatNumber(v);
         if (n === null) return null;
-        return matchesTimePeriod(rule.period, Math.floor(n), _nullishCoalesce(_optionalChain([this, 'access', _53 => _53.sheet, 'access', _54 => _54.today, 'optionalCall', _55 => _55()]), () => ( /* @__PURE__ */ new Date()))) ? rule.style : null;
+        return matchesTimePeriod(rule.period, Math.floor(n), _nullishCoalesce(_optionalChain([this, 'access', _72 => _72.sheet, 'access', _73 => _73.today, 'optionalCall', _74 => _74()]), () => ( /* @__PURE__ */ new Date()))) ? rule.style : null;
       }
       case "colorScale": {
         const n = conditionalFormatNumber(v);
@@ -1888,12 +2210,12 @@ var ConditionalFormatEngine = (_class3 = class {
     }
     return null;
   }
-}, _class3);
+}, _class4);
 function matchesTimePeriod(period, d, today) {
-  const t = _chunkC7P22VIPcjs.serialFromYmd.call(void 0, today.getFullYear(), today.getMonth() + 1, today.getDate());
+  const t = _chunkEWCOFSCQcjs.serialFromYmd.call(void 0, today.getFullYear(), today.getMonth() + 1, today.getDate());
   if (t === null) return false;
   const weekStart = t - today.getDay();
-  const date = _chunkC7P22VIPcjs.serialToDate.call(void 0, d);
+  const date = _chunkEWCOFSCQcjs.serialToDate.call(void 0, d);
   const monthOffset = (k) => {
     if (!date) return false;
     const m = today.getMonth() + k;
@@ -2196,7 +2518,7 @@ var isBlank3 = (v) => v === "" || v === null || v === void 0;
 function valueText2(value) {
   if (isBlank3(value)) return "";
   if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  if (typeof value === "number") return _chunkC7P22VIPcjs.numberToText.call(void 0, value);
+  if (typeof value === "number") return _chunkEWCOFSCQcjs.numberToText.call(void 0, value);
   return String(value);
 }
 function findDataValidation(rules, row, col) {
@@ -2208,7 +2530,7 @@ function evaluate(sheet, rule, formula, row, col, entered) {
   if (!sheet.evaluateFormula) return "#NAME?";
   try {
     return sheet.evaluateFormula(ruleFormulaAt(formula, ruleAnchor(rule.ranges), row, col), row, col, entered);
-  } catch (e7) {
+  } catch (e8) {
     return "#ERROR!";
   }
 }
@@ -2221,7 +2543,7 @@ function getValidationListValues(sheet, rule) {
     const result = evaluate(sheet, rule, f, anchor.row, anchor.col);
     const values = Array.isArray(result) ? result : [result];
     const out = [];
-    for (const v of values) if (!isBlank3(v) && !_chunkC7P22VIPcjs.isFormulaError.call(void 0, v)) out.push(valueText2(v));
+    for (const v of values) if (!isBlank3(v) && !_chunkEWCOFSCQcjs.isFormulaError.call(void 0, v)) out.push(valueText2(v));
     return out;
   }
   const unquoted = f.length >= 2 && f.startsWith('"') && f.endsWith('"') ? f.slice(1, -1) : f;
@@ -2250,7 +2572,7 @@ function compareOp(op, n, a, b) {
 }
 function bound(sheet, rule, text, row, col, entered) {
   if (text === void 0 || text.trim() === "") return null;
-  const value = text.trim().startsWith("=") ? first(evaluate(sheet, rule, text, row, col, entered)) : _chunkC7P22VIPcjs.parseCellInput.call(void 0, text.trim()).value;
+  const value = text.trim().startsWith("=") ? first(evaluate(sheet, rule, text, row, col, entered)) : _chunkEWCOFSCQcjs.parseCellInput.call(void 0, text.trim()).value;
   return conditionalFormatNumber(value);
 }
 function satisfies(sheet, rule, row, col, value, text, entered) {
@@ -2261,18 +2583,18 @@ function satisfies(sheet, rule, row, col, value, text, entered) {
     case "list": {
       const typed = text.trim().toLowerCase();
       return getValidationListValues(sheet, rule).some(
-        (item) => item.toLowerCase() === typed || _chunkC7P22VIPcjs.compareValues.call(void 0, _chunkC7P22VIPcjs.parseCellInput.call(void 0, item).value, value) === 0
+        (item) => item.toLowerCase() === typed || _chunkEWCOFSCQcjs.compareValues.call(void 0, _chunkEWCOFSCQcjs.parseCellInput.call(void 0, item).value, value) === 0
       );
     }
     case "custom":
-      return _chunkC7P22VIPcjs.toBoolean.call(void 0, first(evaluate(sheet, rule, _nullishCoalesce(rule.formula1, () => ( "")), row, col, entered))) === true;
+      return _chunkEWCOFSCQcjs.toBoolean.call(void 0, first(evaluate(sheet, rule, _nullishCoalesce(rule.formula1, () => ( "")), row, col, entered))) === true;
     case "textLength":
       return compareOp(op, Array.from(text).length, bound(sheet, rule, rule.formula1, row, col, entered), bound(sheet, rule, rule.formula2, row, col, entered));
     case "whole":
     case "decimal":
     case "date":
     case "time": {
-      if (_chunkC7P22VIPcjs.isFormulaError.call(void 0, value)) return false;
+      if (_chunkEWCOFSCQcjs.isFormulaError.call(void 0, value)) return false;
       let n = conditionalFormatNumber(value);
       if (n === null) return false;
       if (rule.type === "whole" && !Number.isInteger(n)) return false;
@@ -2301,7 +2623,7 @@ function validateCellInput(sheet, rules, row, col, input) {
     value = first(sheet.evaluateFormula ? safeEval(sheet, input, row, col) : "#NAME?");
     text = valueText2(value);
   } else {
-    value = _chunkC7P22VIPcjs.parseCellInput.call(void 0, input).value;
+    value = _chunkEWCOFSCQcjs.parseCellInput.call(void 0, input).value;
     if (input.startsWith("'")) text = input.slice(1);
   }
   const entered = { row, col, value };
@@ -2310,13 +2632,13 @@ function validateCellInput(sheet, rules, row, col, input) {
 function safeEval(sheet, formula, row, col) {
   try {
     return sheet.evaluateFormula(formula, row, col);
-  } catch (e8) {
+  } catch (e9) {
     return "#ERROR!";
   }
 }
 function findInvalidCells(sheet, rules) {
   const out = [];
-  if (!_optionalChain([rules, 'optionalAccess', _56 => _56.length])) return out;
+  if (!_optionalChain([rules, 'optionalAccess', _75 => _75.length])) return out;
   const seen = /* @__PURE__ */ new Set();
   for (const rule of rules) {
     if (rule.type === "any") continue;
@@ -2327,7 +2649,7 @@ function findInvalidCells(sheet, rules) {
       if (findDataValidation(rules, row, col) !== rule) return;
       const value = sheet.getValue(row, col);
       if (isBlank3(value)) return;
-      const raw = _optionalChain([sheet, 'access', _57 => _57.getInput, 'optionalCall', _58 => _58(row, col)]);
+      const raw = _optionalChain([sheet, 'access', _76 => _76.getInput, 'optionalCall', _77 => _77(row, col)]);
       const text = raw !== void 0 && raw !== "" && !raw.startsWith("=") ? raw.startsWith("'") ? raw.slice(1) : raw : valueText2(value);
       if (!satisfies(sheet, rule, row, col, value, text)) out.push({ row, col });
     });
@@ -2341,8 +2663,8 @@ var DEFAULT_COLUMN_WIDTH = 130;
 var clampCount = (value, max) => Math.max(0, Math.min(Math.floor(_nullishCoalesce(value, () => ( 0))), max));
 function getTableSections(doc) {
   const total = doc.rows.length;
-  const headerRows = clampCount(_optionalChain([doc, 'access', _59 => _59.table, 'optionalAccess', _60 => _60.headerRowCount]), total);
-  const footerRows = clampCount(_optionalChain([doc, 'access', _61 => _61.table, 'optionalAccess', _62 => _62.footerRowCount]), total - headerRows);
+  const headerRows = clampCount(_optionalChain([doc, 'access', _78 => _78.table, 'optionalAccess', _79 => _79.headerRowCount]), total);
+  const footerRows = clampCount(_optionalChain([doc, 'access', _80 => _80.table, 'optionalAccess', _81 => _81.footerRowCount]), total - headerRows);
   return { headerRows, footerRows };
 }
 function getRowSection(doc, rowIndex) {
@@ -2352,8 +2674,8 @@ function getRowSection(doc, rowIndex) {
   return "body";
 }
 function rowPassesFilters(doc, rowIndex, getValue) {
-  const filter = _optionalChain([doc, 'access', _63 => _63.table, 'optionalAccess', _64 => _64.filter]);
-  if (!_optionalChain([filter, 'optionalAccess', _65 => _65.enabled]) || filter.rules.length === 0) return true;
+  const filter = _optionalChain([doc, 'access', _82 => _82.table, 'optionalAccess', _83 => _83.filter]);
+  if (!_optionalChain([filter, 'optionalAccess', _84 => _84.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);
@@ -2362,7 +2684,7 @@ function rowPassesFilters(doc, rowIndex, getValue) {
   });
 }
 function computeRowGroups(doc, getValue) {
-  const grouping = _optionalChain([doc, 'access', _66 => _66.table, 'optionalAccess', _67 => _67.grouping]);
+  const grouping = _optionalChain([doc, 'access', _85 => _85.table, 'optionalAccess', _86 => _86.grouping]);
   if (!grouping) return [];
   const groupCol = doc.columns.findIndex((c) => c.id === grouping.colId);
   if (groupCol === -1) return [];
@@ -2392,9 +2714,9 @@ function computeRowGroups(doc, getValue) {
 }
 function buildSpreadsheetView(doc, getValue) {
   const { headerRows, footerRows } = getTableSections(doc);
-  const frozenRows = clampCount(_optionalChain([doc, 'access', _68 => _68.table, 'optionalAccess', _69 => _69.frozenRowCount]), doc.rows.length);
-  const frozenCols = clampCount(_optionalChain([doc, 'access', _70 => _70.table, 'optionalAccess', _71 => _71.frozenColumnCount]), doc.columns.length);
-  const headerCols = clampCount(_optionalChain([doc, 'access', _72 => _72.table, 'optionalAccess', _73 => _73.headerColumnCount]), doc.columns.length);
+  const frozenRows = clampCount(_optionalChain([doc, 'access', _87 => _87.table, 'optionalAccess', _88 => _88.frozenRowCount]), doc.rows.length);
+  const frozenCols = clampCount(_optionalChain([doc, 'access', _89 => _89.table, 'optionalAccess', _90 => _90.frozenColumnCount]), doc.columns.length);
+  const headerCols = clampCount(_optionalChain([doc, 'access', _91 => _91.table, 'optionalAccess', _92 => _92.headerColumnCount]), doc.columns.length);
   const columns = [];
   let left = 0;
   let hiddenColumnCount = 0;
@@ -2424,7 +2746,7 @@ function buildSpreadsheetView(doc, getValue) {
     if (doc.rows[r].hidden) hiddenRowCount++;
     else if (!rowPassesFilters(doc, r, getValue)) filteredOutCount++;
   }
-  const grouping = _optionalChain([doc, 'access', _74 => _74.table, 'optionalAccess', _75 => _75.grouping]);
+  const grouping = _optionalChain([doc, 'access', _93 => _93.table, 'optionalAccess', _94 => _94.grouping]);
   if (grouping && doc.columns.some((c) => c.id === grouping.colId)) {
     for (const group of groups) {
       rows.push({ kind: "group", group });
@@ -2458,7 +2780,7 @@ function buildSpreadsheetView(doc, getValue) {
     while (run < visible.length && positions.get(visible[run]) === positions.get(visible[0]) + run) run++;
     return { first: visible[0], run };
   };
-  for (const raw of _nullishCoalesce(_optionalChain([doc, 'access', _76 => _76.table, 'optionalAccess', _77 => _77.merges]), () => ( []))) {
+  for (const raw of _nullishCoalesce(_optionalChain([doc, 'access', _95 => _95.table, 'optionalAccess', _96 => _96.merges]), () => ( []))) {
     const merge = normalizeRange(raw);
     const rowIdx = [];
     const colIdx = [];
@@ -2505,15 +2827,42 @@ var createRuntime = (doc) => ({
 });
 var sameName3 = (a, b) => a.toUpperCase() === b.toUpperCase();
 var DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
+var AST_CACHE_SIZE = 1e5;
+var RANGE_CACHE_MIN_CELLS = 256;
 var MAX_SPILL_PASSES = 25;
 var spillCellId = (rowId, colId) => `${rowId}\0${colId}`;
-var SpreadsheetController = (_class4 = class {
-  __init11() {this.activeCell = null}
-  __init12() {this.selectedRange = null}
-  __init13() {this.editingCell = null}
-  __init14() {this.draftValue = ""}
-  __init15() {this.binder = new DataSourceBinder()}
-  __init16() {this.depGraph = new DependencyGraph()}
+var PositionCache = (_class5 = class {constructor() { _class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this); }
+  __init22() {this.map = /* @__PURE__ */ new Map()}
+  __init23() {this.scanned = 0}
+  find(list, id) {
+    const pos = this.map.get(id);
+    if (pos !== void 0 && _optionalChain([list, 'access', _97 => _97[pos], 'optionalAccess', _98 => _98.id]) === id) return pos;
+    if (pos === void 0 && this.scanned <= list.length) {
+      for (let i = this.scanned; i < list.length; i++) this.map.set(list[i].id, i);
+      this.scanned = list.length;
+      const found2 = this.map.get(id);
+      if (found2 !== void 0 && _optionalChain([list, 'access', _99 => _99[found2], 'optionalAccess', _100 => _100.id]) === id) return found2;
+    }
+    this.map.clear();
+    list.forEach((item, i) => this.map.set(item.id, i));
+    this.scanned = list.length;
+    const found = this.map.get(id);
+    return found !== void 0 ? found : -1;
+  }
+}, _class5);
+var positionCaches = /* @__PURE__ */ new WeakMap();
+function positionOf(list, id) {
+  let cache = positionCaches.get(list);
+  if (!cache) positionCaches.set(list, cache = new PositionCache());
+  return cache.find(list, id);
+}
+var SpreadsheetController = (_class6 = class {
+  __init24() {this.activeCell = null}
+  __init25() {this.selectedRange = null}
+  __init26() {this.editingCell = null}
+  __init27() {this.draftValue = ""}
+  __init28() {this.binder = new DataSourceBinder()}
+  __init29() {this.depGraph = new DependencyGraph()}
   
   
   
@@ -2522,30 +2871,34 @@ var SpreadsheetController = (_class4 = class {
   // Workbook: sheets in tab order, the active one, and the one being worked
   // on (the active sheet, or another sheet while one of its cells is read or
   // evaluated). Everything that uses `this.document` works on `ctx`.
-  __init17() {this.runtimes = []}
+  __init30() {this.runtimes = []}
   
   
   // The sheet bound to the primary data source (the first sheet).
-  __init18() {this.boundSheetId = null}
-  __init19() {this.names = []}
+  __init31() {this.boundSheetId = null}
+  __init32() {this.names = []}
   
   
   // History stack for undo/redo
-  __init20() {this.undoStack = []}
-  __init21() {this.redoStack = []}
-  __init22() {this.isApplyingHistory = false}
+  __init33() {this.undoStack = []}
+  __init34() {this.redoStack = []}
+  __init35() {this.isApplyingHistory = false}
   
   // Set while importing TSV: history and recalculation are done once at the end.
-  __init23() {this.batching = false}
-  __init24() {this.pendingCommits = []}
+  __init36() {this.batching = false}
+  __init37() {this.pendingCommits = []}
   // Row being evaluated, so [property] references resolve per row.
-  __init25() {this.evaluatingRowIndex = null}
+  __init38() {this.evaluatingRowIndex = null}
   // Cell being evaluated, for implicit intersection (`=@A:A`).
-  __init26() {this.evaluatingCell = null}
+  __init39() {this.evaluatingCell = null}
   // Dynamic arrays. Spilled values are derived state: they live in the sheet
   // runtimes, not in the documents, and every recalculation rebuilds them.
   // Cells (sheet-qualified keys) whose spill ownership changed during the current pass.
-  __init27() {this.spillChanges = null}
+  __init40() {this.spillChanges = null}
+  __init41() {this.recalcStats = { evaluated: 0, planned: 0, passes: 0 }}
+  // Values of large ranges read while running an evaluation plan (see runEvaluationPlan).
+  __init42() {this.astCache = /* @__PURE__ */ new Map()}
+  __init43() {this.rangeCache = null}
   /** The active sheet's document (the sheet the editor shows). */
   get document() {
     return this.ctx.doc;
@@ -2564,18 +2917,18 @@ var SpreadsheetController = (_class4 = class {
   }
   // Conditional formatting is evaluated lazily (getConditionalFormatOverlay).
   // Cell keys whose values changed since, or 'all' to evaluate from scratch.
-  __init28() {this.cfEngine = null}
-  __init29() {this.cfDirty = "all"}
+  __init44() {this.cfEngine = null}
+  __init45() {this.cfDirty = "all"}
   // Set while a single cell edit notifies, so the change stays incremental.
-  __init30() {this.cfIncremental = false}
+  __init46() {this.cfIncremental = false}
   // Value being entered, seen by validation formulas instead of the cell's value.
-  __init31() {this.valueOverride = null}
+  __init47() {this.valueOverride = null}
   // "Circle invalid data": on/off and the cached cells.
-  __init32() {this.circlesShown = false}
-  __init33() {this.invalidCircles = null}
+  __init48() {this.circlesShown = false}
+  __init49() {this.invalidCircles = null}
   /** Invalid input waiting for the user's answer (see `resolveValidationPrompt`). */
-  __init34() {this.validationPrompt = null}
-  constructor(options = {}) {;_class4.prototype.__init11.call(this);_class4.prototype.__init12.call(this);_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);_class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this);_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);_class4.prototype.__init29.call(this);_class4.prototype.__init30.call(this);_class4.prototype.__init31.call(this);_class4.prototype.__init32.call(this);_class4.prototype.__init33.call(this);_class4.prototype.__init34.call(this);_class4.prototype.__init35.call(this);
+  __init50() {this.validationPrompt = null}
+  constructor(options = {}) {;_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);_class6.prototype.__init27.call(this);_class6.prototype.__init28.call(this);_class6.prototype.__init29.call(this);_class6.prototype.__init30.call(this);_class6.prototype.__init31.call(this);_class6.prototype.__init32.call(this);_class6.prototype.__init33.call(this);_class6.prototype.__init34.call(this);_class6.prototype.__init35.call(this);_class6.prototype.__init36.call(this);_class6.prototype.__init37.call(this);_class6.prototype.__init38.call(this);_class6.prototype.__init39.call(this);_class6.prototype.__init40.call(this);_class6.prototype.__init41.call(this);_class6.prototype.__init42.call(this);_class6.prototype.__init43.call(this);_class6.prototype.__init44.call(this);_class6.prototype.__init45.call(this);_class6.prototype.__init46.call(this);_class6.prototype.__init47.call(this);_class6.prototype.__init48.call(this);_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);
     const defaultCols = [
       { id: "col_a", key: "A", title: "A", width: 120, type: "freeform" },
       { id: "col_b", key: "B", title: "B", width: 120, type: "freeform" },
@@ -2589,14 +2942,14 @@ var SpreadsheetController = (_class4 = class {
       type: "freeform"
     }));
     const first2 = {
-      id: _optionalChain([options, 'access', _78 => _78.document, 'optionalAccess', _79 => _79.id]) || `sheet_${Date.now()}`,
-      name: _optionalChain([options, 'access', _80 => _80.document, 'optionalAccess', _81 => _81.name]) || "Sheet 1",
-      columns: _optionalChain([options, 'access', _82 => _82.document, 'optionalAccess', _83 => _83.columns]) || defaultCols,
-      rows: _optionalChain([options, 'access', _84 => _84.document, 'optionalAccess', _85 => _85.rows]) || defaultRows,
-      cells: _optionalChain([options, 'access', _86 => _86.document, 'optionalAccess', _87 => _87.cells]) || {},
-      createdAt: _optionalChain([options, 'access', _88 => _88.document, 'optionalAccess', _89 => _89.createdAt]) || Date.now(),
-      updatedAt: _optionalChain([options, 'access', _90 => _90.document, 'optionalAccess', _91 => _91.updatedAt]) || Date.now(),
-      ..._optionalChain([options, 'access', _92 => _92.document, 'optionalAccess', _93 => _93.table]) ? { table: options.document.table } : {}
+      id: _optionalChain([options, 'access', _101 => _101.document, 'optionalAccess', _102 => _102.id]) || `sheet_${Date.now()}`,
+      name: _optionalChain([options, 'access', _103 => _103.document, 'optionalAccess', _104 => _104.name]) || "Sheet 1",
+      columns: _optionalChain([options, 'access', _105 => _105.document, 'optionalAccess', _106 => _106.columns]) || defaultCols,
+      rows: _optionalChain([options, 'access', _107 => _107.document, 'optionalAccess', _108 => _108.rows]) || defaultRows,
+      cells: _optionalChain([options, 'access', _109 => _109.document, 'optionalAccess', _110 => _110.cells]) || {},
+      createdAt: _optionalChain([options, 'access', _111 => _111.document, 'optionalAccess', _112 => _112.createdAt]) || Date.now(),
+      updatedAt: _optionalChain([options, 'access', _113 => _113.document, 'optionalAccess', _114 => _114.updatedAt]) || Date.now(),
+      ..._optionalChain([options, 'access', _115 => _115.document, 'optionalAccess', _116 => _116.table]) ? { table: options.document.table } : {}
     };
     if (options.workbook && options.workbook.sheets.length > 0) {
       this.setWorkbookState(options.workbook, false);
@@ -2615,9 +2968,9 @@ var SpreadsheetController = (_class4 = class {
     if (options.dataSources) {
       options.dataSources.forEach((ds) => this.binder.register(ds));
     }
-    this.evaluator = new (0, _chunkC7P22VIPcjs.FormulaEvaluator)({
+    this.evaluator = new (0, _chunkEWCOFSCQcjs.FormulaEvaluator)({
       resolveCell: (colStr, rowNum, sheet) => this.onSheet(sheet, () => this.resolveCellByCoord(colStr, rowNum)),
-      resolveRange: (sCol, sRow, eCol, eRow, sheet) => this.onSheet(sheet, () => this.resolveRangeByCoords(sCol, sRow, eCol, eRow)),
+      resolveRange: (sCol, sRow, eCol, eRow, sheet, options2) => this.onSheet(sheet, () => this.resolveRangeByCoords(sCol, sRow, eCol, eRow, options2)),
       resolveProperty: (prop) => this.resolveCurrentRowProperty(prop),
       resolveSpill: (colStr, rowNum, sheet) => this.onSheet(sheet, () => this.resolveSpillByCoord(colStr, rowNum)),
       resolveSheetSpan: (first3, last) => this.resolveSheetSpan(first3, last),
@@ -2744,7 +3097,7 @@ var SpreadsheetController = (_class4 = class {
     for (const rt of this.runtimes) this.withSheet(rt, () => this.rederiveTypedValues());
     this.recalculateAll();
     this.notifyChange();
-    _optionalChain([this, 'access', _94 => _94.onSelectionChange, 'optionalCall', _95 => _95(this.activeCell, this.selectedRange)]);
+    _optionalChain([this, 'access', _117 => _117.onSelectionChange, 'optionalCall', _118 => _118(this.activeCell, this.selectedRange)]);
   }
   workbookSnapshot() {
     return {
@@ -2810,13 +3163,13 @@ var SpreadsheetController = (_class4 = class {
    * number) when `format` is unset or `text` (the default of new columns).
    */
   typedCell(raw, format, col, existing) {
-    const parsed = _chunkC7P22VIPcjs.parseCellInput.call(void 0, raw);
+    const parsed = _chunkEWCOFSCQcjs.parseCellInput.call(void 0, raw);
     const fixed = this.fixedNumberFormat(col, existing);
     const numberFormat = _nullishCoalesce(fixed, () => ( parsed.numberFormat));
     return {
       value: parsed.value,
       ...numberFormat ? { numberFormat } : {},
-      ..._optionalChain([existing, 'optionalAccess', _96 => _96.explicitNumberFormat]) ? { explicitNumberFormat: true } : {},
+      ..._optionalChain([existing, 'optionalAccess', _119 => _119.explicitNumberFormat]) ? { explicitNumberFormat: true } : {},
       format: fixed === void 0 && parsed.cellFormat && (!format || format === "text") ? parsed.cellFormat : format
     };
   }
@@ -2825,14 +3178,14 @@ var SpreadsheetController = (_class4 = class {
    * one, else its column's. Undefined lets typed input choose one.
    */
   fixedNumberFormat(col, existing) {
-    if (_optionalChain([existing, 'optionalAccess', _97 => _97.explicitNumberFormat]) && existing.numberFormat !== void 0) return existing.numberFormat;
-    return _optionalChain([col, 'optionalAccess', _98 => _98.numberFormat]) && !isGeneralNumberFormat(col.numberFormat) ? col.numberFormat : void 0;
+    if (_optionalChain([existing, 'optionalAccess', _120 => _120.explicitNumberFormat]) && existing.numberFormat !== void 0) return existing.numberFormat;
+    return _optionalChain([col, 'optionalAccess', _121 => _121.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 _optionalChain([existing, 'optionalAccess', _99 => _99.explicitNumberFormat]) ? { numberFormat, explicitNumberFormat: true } : { numberFormat };
+    return _optionalChain([existing, 'optionalAccess', _122 => _122.explicitNumberFormat]) ? { numberFormat, explicitNumberFormat: true } : { numberFormat };
   }
   /**
    * Typed input for a bound field, coerced by the field's declared type:
@@ -2842,9 +3195,9 @@ var SpreadsheetController = (_class4 = class {
    */
   boundInputValue(dataSourceId, field, raw) {
     if (raw.startsWith("=")) return raw;
-    const type = _optionalChain([this, 'access', _100 => _100.binder, 'access', _101 => _101.getDataSource, 'call', _102 => _102(dataSourceId), 'optionalAccess', _103 => _103.getFields, 'call', _104 => _104(), 'access', _105 => _105.find, 'call', _106 => _106((f) => f.key === field), 'optionalAccess', _107 => _107.type]);
+    const type = _optionalChain([this, 'access', _123 => _123.binder, 'access', _124 => _124.getDataSource, 'call', _125 => _125(dataSourceId), 'optionalAccess', _126 => _126.getFields, 'call', _127 => _127(), 'access', _128 => _128.find, 'call', _129 => _129((f) => f.key === field), 'optionalAccess', _130 => _130.type]);
     if (type !== "number" && type !== "boolean" && type !== "date") return raw;
-    const parsed = _chunkC7P22VIPcjs.parseCellInput.call(void 0, raw);
+    const parsed = _chunkEWCOFSCQcjs.parseCellInput.call(void 0, 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;
@@ -2873,10 +3226,12 @@ var SpreadsheetController = (_class4 = class {
       r.index = idx;
     });
     this.document.columns.forEach((c, idx) => {
-      c.key = _chunkC7P22VIPcjs.indexToColName.call(void 0, idx);
+      c.key = _chunkEWCOFSCQcjs.indexToColName.call(void 0, idx);
     });
   }
   getColumn(colIdOrKey) {
+    const byId = this.findColumn(colIdOrKey);
+    if (byId) return byId;
     return this.document.columns.find(
       (c) => c.id === colIdOrKey || c.key.toUpperCase() === colIdOrKey.toUpperCase()
     );
@@ -2885,18 +3240,48 @@ var SpreadsheetController = (_class4 = class {
     if (typeof rowIdOrIndex === "number") {
       return this.document.rows[rowIdOrIndex];
     }
-    return this.document.rows.find((r) => r.id === rowIdOrIndex);
+    return this.findRow(rowIdOrIndex);
+  }
+  /** The row with this id on the current sheet (constant time, see `PositionCache`). */
+  findRow(rowId) {
+    const pos = positionOf(this.document.rows, rowId);
+    return pos < 0 ? void 0 : this.document.rows[pos];
+  }
+  /** The column with this id on the current sheet. */
+  findColumn(colId) {
+    const pos = positionOf(this.document.columns, colId);
+    return pos < 0 ? void 0 : this.document.columns[pos];
+  }
+  /** The column whose key is `key` (`A`, `B`, …): keys follow column positions. */
+  columnByKey(key) {
+    const upper = key.toUpperCase();
+    const col = this.document.columns[_chunkEWCOFSCQcjs.colNameToIndex.call(void 0, upper)];
+    if (col && col.key.toUpperCase() === upper) return col;
+    return this.document.columns.find((c) => c.key.toUpperCase() === upper);
   }
   getCell(rowId, colId) {
-    const existing = _optionalChain([this, 'access', _108 => _108.document, 'access', _109 => _109.cells, 'access', _110 => _110[rowId], 'optionalAccess', _111 => _111[colId]]);
+    const existing = _optionalChain([this, 'access', _131 => _131.document, 'access', _132 => _132.cells, 'access', _133 => _133[rowId], 'optionalAccess', _134 => _134[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);
+    return this.finishCell(existing, this.findRow(rowId), this.findColumn(colId));
+  }
+  /** `getCell` for a row and column already looked up. */
+  cellOf(row, col) {
+    const existing = _optionalChain([this, 'access', _135 => _135.document, 'access', _136 => _136.cells, 'access', _137 => _137[row.id], 'optionalAccess', _138 => _138[col.id]]);
+    if (existing && existing.raw !== "") return existing;
+    if (this.spillCells.size > 0) {
+      const spilled = this.spillCells.get(spillCellId(row.id, col.id));
+      if (spilled) return spilled;
+    }
+    if (existing && !existing.explicitNumberFormat) return existing;
+    return this.finishCell(existing, row, col);
+  }
+  /** A cell with no value of its own: derived (bound, column formula, blank), keeping an explicit number format. */
+  finishCell(existing, row, col) {
     const derived = this.getDerivedCell(row, col);
     if (!existing) return derived;
     if (derived.raw === "") return existing;
@@ -2925,29 +3310,30 @@ var SpreadsheetController = (_class4 = class {
         ...this.fixedNumberFormatFields(col, void 0)
       };
     }
-    return { raw: "", value: "", format: _optionalChain([col, 'optionalAccess', _112 => _112.format]), ...this.fixedNumberFormatFields(col, void 0) };
+    return { raw: "", value: "", format: _optionalChain([col, 'optionalAccess', _139 => _139.format]), ...this.fixedNumberFormatFields(col, void 0) };
   }
   setCellValue(rowId, colId, raw) {
-    this.recordSnapshot();
+    this.recordCellSnapshot(rowId, colId);
     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 col = this.findColumn(colId);
+    const row = this.findRow(rowId);
     const isFormula = raw.startsWith("=");
     const existing = this.document.cells[rowId][colId];
     let cell;
-    if (_optionalChain([col, 'optionalAccess', _113 => _113.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _114 => _114.recordId])) {
+    if (_optionalChain([col, 'optionalAccess', _140 => _140.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _141 => _141.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: _optionalChain([col, 'optionalAccess', _115 => _115.format]), ...this.fixedNumberFormatFields(col, existing) };
+      cell = { raw, value: raw, format: _optionalChain([col, 'optionalAccess', _142 => _142.format]), ...this.fixedNumberFormatFields(col, existing) };
     } else {
-      cell = { raw, ...this.typedCell(raw, _optionalChain([col, 'optionalAccess', _116 => _116.format]), col, existing) };
+      cell = { raw, ...this.typedCell(raw, _optionalChain([col, 'optionalAccess', _143 => _143.format]), col, existing) };
     }
     const cellKey2 = this.getCellKey(rowId, colId);
     this.registerFormula(cellKey2, isFormula ? raw : null);
+    this.dropStaleSpillEdges(cellKey2, raw);
     this.document.cells[rowId][colId] = cell;
     this.document.updatedAt = Date.now();
     if (this.batching) {
@@ -2962,12 +3348,12 @@ var SpreadsheetController = (_class4 = class {
     } finally {
       this.cfIncremental = false;
     }
-    const evaluatedVal = _optionalChain([this, 'access', _117 => _117.document, 'access', _118 => _118.cells, 'access', _119 => _119[rowId], 'access', _120 => _120[colId], 'optionalAccess', _121 => _121.value]);
-    _optionalChain([this, 'access', _122 => _122.onCellCommit, 'optionalCall', _123 => _123(rowId, colId, raw, evaluatedVal)]);
+    const evaluatedVal = _optionalChain([this, 'access', _144 => _144.document, 'access', _145 => _145.cells, 'access', _146 => _146[rowId], 'access', _147 => _147[colId], 'optionalAccess', _148 => _148.value]);
+    _optionalChain([this, 'access', _149 => _149.onCellCommit, 'optionalCall', _150 => _150(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);
+    const row = this.findRow(rowId);
+    const col = this.findColumn(colId);
     if (!row || !col) return `${colId}_${rowId}`;
     return `${col.key}${row.index + 1}`.toUpperCase();
   }
@@ -2990,22 +3376,57 @@ var SpreadsheetController = (_class4 = class {
     const key = this.qualify(cellKey2);
     if (!formula || !formula.startsWith("=")) {
       this.depGraph.setCellDependencies(key, []);
+      this.depGraph.setVolatile(key, false);
       return;
     }
     let ast;
     try {
-      ast = _chunkC7P22VIPcjs.parseFormula.call(void 0, formula);
-    } catch (e9) {
+      ast = this.parseCached(formula);
+    } catch (e10) {
       this.depGraph.setCellDependencies(key, []);
+      this.depGraph.setVolatile(key, false);
       return;
     }
     const deps = /* @__PURE__ */ new Set();
-    this.collectDependencies(ast, this.ctx, deps, /* @__PURE__ */ new Set());
+    const volatile = { found: false };
+    this.collectDependencies(ast, this.ctx, deps, /* @__PURE__ */ new Set(), volatile);
     this.depGraph.setCellDependencies(key, deps);
+    this.depGraph.setVolatile(key, volatile.found);
+  }
+  /**
+   * Spill edges made stale by new input in `cellKey`: the edges of the array
+   * it anchored (its new formula re-spills when evaluated; spill changes
+   * are recalculated in a further pass) and, when it now holds input, its
+   * edge to the anchor whose values it held. Left in place they can close
+   * false cycles with the new formulas before the anchors are evaluated.
+   */
+  dropStaleSpillEdges(cellKey2, raw) {
+    const key = this.qualify(cellKey2);
+    this.depGraph.setSpillEdges(key, []);
+    if (raw !== "") this.depGraph.detachSpilledCell(key);
+  }
+  /**
+   * The parsed formula, shared by dependency registration and evaluation (so
+   * a load parses each formula once). ASTs are never mutated.
+   */
+  parseCached(formula) {
+    let ast = this.astCache.get(formula);
+    if (!ast) {
+      ast = _chunkEWCOFSCQcjs.parseFormula.call(void 0, formula);
+      if (this.astCache.size >= AST_CACHE_SIZE) this.astCache.clear();
+      this.astCache.set(formula, ast);
+    }
+    return ast;
   }
-  /** Adds the qualified keys `ast` depends on, with unqualified references on `home`. */
-  collectDependencies(ast, home, out, seenNames) {
-    for (const dep of extractCellDependencies(ast)) {
+  /**
+   * Adds the qualified keys `ast` depends on, with unqualified references on
+   * `home`: cells, and ranges kept whole (`SHEETID!A1:A50000`), which the
+   * graph indexes as intervals instead of one key per cell. Sets
+   * `volatile.found` when a volatile function (NOW, RAND, …) is used,
+   * directly or through a defined name.
+   */
+  collectDependencies(ast, home, out, seenNames, volatile = { found: false }) {
+    for (const dep of extractReferenceDependencies(ast)) {
       let sheets;
       if (dep.sheet === void 0) {
         sheets = [home];
@@ -3017,11 +3438,19 @@ var SpreadsheetController = (_class4 = class {
         sheets = Array.isArray(span) ? span.map((name) => this.findRuntimeByName(name)) : [];
       }
       for (const rt of sheets) {
-        out.add(dep.row === 0 ? columnDependencyKey(`${rt.doc.id}!${dep.col}`) : this.qualify(`${dep.col}${dep.row}`, rt));
+        out.add(
+          dep.kind === "cell" ? this.qualify(`${dep.col}${dep.row}`, rt) : rangeDependencyKey(dep.startCol, dep.startRow, dep.endCol, dep.endRow, rt.doc.id)
+        );
       }
     }
     for (const used of extractNameDependencies(ast)) {
-      if (used.call && _chunkC7P22VIPcjs.getFormulaFunction.call(void 0, used.name)) continue;
+      if (used.call) {
+        const fn = _chunkEWCOFSCQcjs.getFormulaFunction.call(void 0, used.name);
+        if (fn) {
+          if (fn.volatile) volatile.found = true;
+          continue;
+        }
+      }
       const lookupSheet = used.sheet === void 0 ? home : this.findRuntimeByName(used.sheet);
       if (!lookupSheet) continue;
       const def = this.findName(used.name, lookupSheet);
@@ -3032,8 +3461,8 @@ var SpreadsheetController = (_class4 = class {
       if (seenNames.has(seenKey)) continue;
       seenNames.add(seenKey);
       try {
-        this.collectDependencies(_chunkC7P22VIPcjs.parseFormula.call(void 0, def.refersTo), nameHome, out, seenNames);
-      } catch (e10) {
+        this.collectDependencies(_chunkEWCOFSCQcjs.parseFormula.call(void 0, def.refersTo), nameHome, out, seenNames, volatile);
+      } catch (e11) {
       }
     }
   }
@@ -3047,18 +3476,49 @@ var SpreadsheetController = (_class4 = class {
   recalculateKeys(keys, includeDependents) {
     let pending = Array.from(keys);
     let withDependents = includeDependents;
-    for (let pass = 0; pass < MAX_SPILL_PASSES && pending.length > 0; pass++) {
+    let withVolatile = includeDependents;
+    const stats = { evaluated: 0, planned: 0, passes: 0 };
+    this.recalcStats = stats;
+    for (let pass = 0; pass < MAX_SPILL_PASSES && (pending.length > 0 || withVolatile); pass++) {
       const changed = /* @__PURE__ */ new Set();
       this.spillChanges = changed;
       try {
-        this.runEvaluationPlan(this.depGraph.getEvaluationPlan(pending, { includeDependents: withDependents }));
+        const plan = this.depGraph.getEvaluationPlan(pending, { includeDependents: withDependents, includeVolatile: withVolatile });
+        stats.planned += plan.order.length;
+        stats.passes++;
+        this.runEvaluationPlan(plan);
       } finally {
         this.spillChanges = null;
       }
       pending = Array.from(changed);
       withDependents = true;
+      withVolatile = false;
     }
   }
+  /**
+   * Recalculates cells of the current sheet whose stored input changed (their
+   * formulas already registered), with their dependents, in one plan.
+   */
+  recalculateWrittenCells(cells) {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [rowId, colId] of cells) {
+      const cellKey2 = this.getCellKey(rowId, colId);
+      keys.add(this.qualify(cellKey2));
+      const anchor = this.spilledBy.get(cellKey2);
+      if (anchor) keys.add(this.qualify(anchor));
+    }
+    this.recalculateKeys(keys, true);
+  }
+  /**
+   * Work done by the last recalculation (an edit, paste, import, load or
+   * full recalculation): formulas evaluated, cells planned (formulas, their
+   * dependents and spilled cells) and passes (more than one when spill
+   * ranges changed). Deterministic, unlike timings: use it to check that an
+   * edit only recalculates what depends on it.
+   */
+  getRecalculationStats() {
+    return { ...this.recalcStats };
+  }
   /**
    * Rebuilds the dependency graph from scratch and recalculates every formula
    * in dependency order.
@@ -3072,10 +3532,14 @@ var SpreadsheetController = (_class4 = class {
         this.spills.clear();
         this.spilledBy.clear();
         this.spillCells.clear();
+        const columns = this.document.columns;
+        const deriving = columns.map((col) => col.type === "bound" || col.type === "formula");
         for (const row of this.document.rows) {
-          for (const col of this.document.columns) {
-            const cell = _nullishCoalesce(_optionalChain([this, 'access', _124 => _124.document, 'access', _125 => _125.cells, 'access', _126 => _126[row.id], 'optionalAccess', _127 => _127[col.id]]), () => ( this.getDerivedCell(row, col)));
-            if (cell.raw.startsWith("=")) {
+          const stored = this.document.cells[row.id];
+          for (let c = 0; c < columns.length; c++) {
+            const col = columns[c];
+            const cell = _nullishCoalesce(_optionalChain([stored, 'optionalAccess', _151 => _151[col.id]]), () => ( (deriving[c] ? this.getDerivedCell(row, col) : null)));
+            if (cell && typeof cell.raw === "string" && cell.raw.startsWith("=")) {
               const cellKey2 = `${col.key}${row.index + 1}`.toUpperCase();
               this.registerFormula(cellKey2, cell.raw);
               formulaKeys.push(this.qualify(cellKey2));
@@ -3087,25 +3551,45 @@ var SpreadsheetController = (_class4 = class {
     this.recalculateKeys(formulaKeys, false);
   }
   runEvaluationPlan(plan) {
-    for (const qualified of plan.order) {
-      const located = this.unqualify(qualified);
-      if (!located) continue;
-      const onActive = located.rt === this.active;
-      this.withSheet(located.rt, () => {
-        if (onActive) this.markValueChanged(located.key);
-        if (plan.cyclic.has(qualified)) {
-          this.markCycle(located.key);
-        } else {
-          this.evalSingleCellByKey(located.key);
-        }
-        if (onActive) this.markValueChanged(located.key);
-      });
+    this.rangeCache = /* @__PURE__ */ new Map();
+    try {
+      for (const qualified of plan.order) {
+        const located = this.unqualify(qualified);
+        if (!located) continue;
+        const onActive = located.rt === this.active;
+        this.withSheet(located.rt, () => {
+          const hadSpill = this.spills.has(located.key);
+          const spillChanges = _nullishCoalesce(_optionalChain([this, 'access', _152 => _152.spillChanges, 'optionalAccess', _153 => _153.size]), () => ( 0));
+          if (onActive) this.markValueChanged(located.key);
+          if (plan.cyclic.has(qualified)) {
+            this.markCycle(located.key);
+          } else {
+            this.evalSingleCellByKey(located.key);
+          }
+          if (onActive) this.markValueChanged(located.key);
+          const spilled = hadSpill || this.spills.has(located.key) || (_nullishCoalesce(_optionalChain([this, 'access', _154 => _154.spillChanges, 'optionalAccess', _155 => _155.size]), () => ( 0))) !== spillChanges;
+          this.invalidateRangeCache(located.rt.doc.id, spilled ? null : _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, located.key.replace(/\d+$/, "")));
+        });
+      }
+    } finally {
+      this.rangeCache = null;
+    }
+  }
+  /**
+   * Drops cached ranges of `sheetId` that cover column `col` (whose cell was
+   * just evaluated), or all of the sheet's when `col` is null (spilled
+   * values moved or changed).
+   */
+  invalidateRangeCache(sheetId, col) {
+    if (!this.rangeCache || this.rangeCache.size === 0) return;
+    for (const [key, entry] of this.rangeCache) {
+      if (entry.sheet === sheetId && (col === null || col >= entry.c0 && col <= entry.c1)) this.rangeCache.delete(key);
     }
   }
   locateCellKey(cellKey2) {
     const match = cellKey2.match(/^([A-Za-z]+)(\d+)$/);
     if (!match) return null;
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === match[1].toUpperCase());
+    const col = this.columnByKey(match[1]);
     const row = this.document.rows[parseInt(match[2], 10) - 1];
     return col && row ? { row, col } : null;
   }
@@ -3117,10 +3601,8 @@ var SpreadsheetController = (_class4 = class {
     if (!cell.raw.startsWith("=")) return;
     if (!this.document.cells[row.id]) this.document.cells[row.id] = {};
     const qualified = this.qualify(cellKey2);
-    const deps = this.depGraph.getDependencies(qualified);
-    const selfReference = deps.includes(qualified) || deps.includes(columnDependencyKey(`${this.document.id}!${col.key}`));
-    const spilledKeys = this.depGraph.getSpilledKeys(qualified);
-    const ownSpill = deps.find((dep) => spilledKeys.includes(dep));
+    const selfReference = this.depGraph.dependsOn(qualified, qualified);
+    const ownSpill = selfReference ? void 0 : this.depGraph.getSpilledKeys(qualified).find((key) => this.depGraph.dependsOn(qualified, key));
     const errorMessage = selfReference ? "This formula can't reference its own cell." : ownSpill ? `This formula refers to ${ownSpill.slice(ownSpill.lastIndexOf("!") + 1)}, 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(cellKey2.toUpperCase(), true);
     this.document.cells[row.id][col.id] = { ...cell, value: "#CYCLE!", error: "#CYCLE!", errorMessage };
@@ -3130,7 +3612,7 @@ var SpreadsheetController = (_class4 = class {
     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 col = this.columnByKey(colName);
     const row = this.document.rows[rowNum - 1];
     if (!col || !row) return;
     const cell = this.getCell(row.id, col.id);
@@ -3145,13 +3627,19 @@ var SpreadsheetController = (_class4 = class {
     try {
       this.evaluatingRowIndex = rowNum - 1;
       this.evaluatingCell = { col: colName, row: rowNum };
-      const result = this.evaluator.evaluateWithDiagnostics(cell.raw);
+      this.recalcStats.evaluated++;
+      let parsed = cell.raw;
+      try {
+        parsed = this.parseCached(cell.raw);
+      } catch (e12) {
+      }
+      const result = this.evaluator.evaluateWithDiagnostics(parsed);
       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);
+        const blocked = this.placeSpill(`${colName}${rowNum}`, rowNum - 1, positionOf(this.document.columns, col.id), result.array);
         if (blocked) {
           value = "#SPILL!";
           error = "#SPILL!";
@@ -3182,7 +3670,7 @@ var SpreadsheetController = (_class4 = class {
   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 = `${_chunkC7P22VIPcjs.indexToColName.call(void 0, area.startCol)}${area.startRow + 1}:${_chunkC7P22VIPcjs.indexToColName.call(void 0, area.endCol)}${area.endRow + 1}`;
+    const label = `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, area.startCol)}${area.startRow + 1}:${_chunkEWCOFSCQcjs.indexToColName.call(void 0, area.endCol)}${area.endRow + 1}`;
     let reason = null;
     const blockers = [];
     if (area.endRow >= this.document.rows.length || area.endCol >= this.document.columns.length) {
@@ -3196,7 +3684,7 @@ var SpreadsheetController = (_class4 = class {
           if (r === row && c === col) continue;
           const rowObj = this.document.rows[r];
           const key = `${column.key}${r + 1}`.toUpperCase();
-          const stored = _optionalChain([this, 'access', _128 => _128.document, 'access', _129 => _129.cells, 'access', _130 => _130[rowObj.id], 'optionalAccess', _131 => _131[column.id]]);
+          const stored = _optionalChain([this, 'access', _156 => _156.document, 'access', _157 => _157.cells, 'access', _158 => _158[rowObj.id], 'optionalAccess', _159 => _159[column.id]]);
           const raw = stored ? stored.raw : this.getDerivedCell(rowObj, column).raw;
           const owner = this.spilledBy.get(key);
           if (raw !== "") {
@@ -3215,6 +3703,7 @@ var SpreadsheetController = (_class4 = class {
       return reason;
     }
     const previous = this.spills.get(anchor);
+    const linked = new Set(this.depGraph.getSpilledKeys(this.qualify(anchor)));
     const cells = [];
     for (let c = 0; c < cols; c++) {
       const column = this.document.columns[col + c];
@@ -3228,16 +3717,18 @@ var SpreadsheetController = (_class4 = class {
           value,
           format: column.format,
           spillAnchor: anchor,
-          ...this.fixedNumberFormatFields(column, _optionalChain([this, 'access', _132 => _132.document, 'access', _133 => _133.cells, 'access', _134 => _134[rowObj.id], 'optionalAccess', _135 => _135[column.id]]))
+          ...this.fixedNumberFormatFields(column, _optionalChain([this, 'access', _160 => _160.document, 'access', _161 => _161.cells, 'access', _162 => _162[rowObj.id], 'optionalAccess', _163 => _163[column.id]]))
         };
-        if (_chunkC7P22VIPcjs.isFormulaError.call(void 0, value)) {
+        if (_chunkEWCOFSCQcjs.isFormulaError.call(void 0, value)) {
           display.error = value;
-          display.errorMessage = _chunkC7P22VIPcjs.describeFormulaError.call(void 0, value);
+          display.errorMessage = _chunkEWCOFSCQcjs.describeFormulaError.call(void 0, value);
         }
         this.spillCells.set(spillCellId(rowObj.id, column.id), display);
         if (this.spilledBy.get(key) !== anchor) {
           this.spilledBy.set(key, anchor);
-          _optionalChain([this, 'access', _136 => _136.spillChanges, 'optionalAccess', _137 => _137.add, 'call', _138 => _138(this.qualify(key))]);
+          _optionalChain([this, 'access', _164 => _164.spillChanges, 'optionalAccess', _165 => _165.add, 'call', _166 => _166(this.qualify(key))]);
+        } else if (!linked.has(this.qualify(key))) {
+          _optionalChain([this, 'access', _167 => _167.spillChanges, 'optionalAccess', _168 => _168.add, 'call', _169 => _169(this.qualify(key))]);
         }
         cells.push({ key, rowId: rowObj.id, colId: column.id });
       }
@@ -3266,13 +3757,13 @@ var SpreadsheetController = (_class4 = class {
     if (this.spilledBy.get(cell.key) !== anchor) return;
     this.spilledBy.delete(cell.key);
     this.spillCells.delete(spillCellId(cell.rowId, cell.colId));
-    _optionalChain([this, 'access', _139 => _139.spillChanges, 'optionalAccess', _140 => _140.add, 'call', _141 => _141(this.qualify(cell.key))]);
+    _optionalChain([this, 'access', _170 => _170.spillChanges, 'optionalAccess', _171 => _171.add, 'call', _172 => _172(this.qualify(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 _chunkC7P22VIPcjs.isFormulaError.call(void 0, value) ? value : "#REF!";
+    return _chunkEWCOFSCQcjs.isFormulaError.call(void 0, value) ? value : "#REF!";
   }
   toSpill(record) {
     const row = this.document.rows[record.row];
@@ -3295,7 +3786,7 @@ var SpreadsheetController = (_class4 = class {
    */
   getSpillAt(row, col) {
     if (this.spills.size === 0) return null;
-    const key = `${_chunkC7P22VIPcjs.indexToColName.call(void 0, col)}${row + 1}`;
+    const key = `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, col)}${row + 1}`;
     const record = _nullishCoalesce(this.spills.get(key), () => ( this.spills.get(_nullishCoalesce(this.spilledBy.get(key), () => ( "")))));
     return record ? this.toSpill(record) : null;
   }
@@ -3317,40 +3808,69 @@ var SpreadsheetController = (_class4 = class {
     return false;
   }
   resolveCellByCoord(colStr, rowNum) {
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === colStr.toUpperCase());
+    const col = this.columnByKey(colStr);
     const row = this.document.rows[rowNum - 1];
     if (!col || !row) return 0;
     const override = this.valueOverride;
     if (override && override.row === rowNum - 1 && this.document.columns[override.col] === col) return override.value;
-    return _nullishCoalesce(this.getCell(row.id, col.id).value, () => ( ""));
+    return _nullishCoalesce(this.cellOf(row, col).value, () => ( ""));
   }
-  resolveRangeByCoords(sCol, sRow, eCol, eRow) {
-    const startC = _chunkC7P22VIPcjs.colNameToIndex.call(void 0, sCol);
-    const endC = _chunkC7P22VIPcjs.colNameToIndex.call(void 0, eCol);
+  /**
+   * Values of a range, column by column. With `skipBlanks` (functions that
+   * ignore blank cells: SUM, COUNT, AVERAGE, …) blank cells are left out, so
+   * a sparse column costs one lookup per row and no array slot.
+   */
+  resolveRangeByCoords(sCol, sRow, eCol, eRow, options) {
+    const startC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, sCol);
+    const endC = _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, 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), _chunkC7P22VIPcjs.WHOLE_COLUMN_END_ROW, this.document.rows.length);
+    const maxR = Math.min(Math.max(sRow, eRow), _chunkEWCOFSCQcjs.WHOLE_COLUMN_END_ROW, this.document.rows.length);
+    const skipBlanks = _optionalChain([options, 'optionalAccess', _173 => _173.skipBlanks]) === true;
+    const cacheable = this.rangeCache !== null && !this.valueOverride && (maxC - minC + 1) * (maxR - minR + 1) >= RANGE_CACHE_MIN_CELLS;
+    const cacheKey = cacheable ? `${this.document.id}|${minC}|${maxC}|${minR}|${maxR}|${skipBlanks ? 1 : 0}` : "";
+    if (cacheable) {
+      const hit = this.rangeCache.get(cacheKey);
+      if (hit) return hit.values.slice();
+    }
+    const rows = this.document.rows;
+    const cells = this.document.cells;
+    const spills = this.spillCells.size > 0 ? this.spillCells : null;
     const results = [];
     for (let c = minC; c <= maxC; c++) {
-      const colName = _chunkC7P22VIPcjs.indexToColName.call(void 0, c);
-      const col = this.document.columns.find((colDef) => colDef.key.toUpperCase() === colName);
+      const col = this.columnByKey(_chunkEWCOFSCQcjs.indexToColName.call(void 0, c));
       if (!col) continue;
+      const plain = col.type !== "bound" && col.type !== "formula";
+      const colId = col.id;
       const override = this.valueOverride && this.document.columns[this.valueOverride.col] === col ? this.valueOverride : null;
       for (let r = minR; r <= maxR; r++) {
-        const row = this.document.rows[r - 1];
+        const row = rows[r - 1];
         if (!row) continue;
+        let value;
         if (override && override.row === r - 1) {
-          results.push(override.value);
-          continue;
+          value = override.value;
+        } else {
+          const stored = _optionalChain([cells, 'access', _174 => _174[row.id], 'optionalAccess', _175 => _175[colId]]);
+          if (stored && stored.raw !== "") value = stored.value;
+          else {
+            const spilled = _optionalChain([spills, 'optionalAccess', _176 => _176.get, 'call', _177 => _177(spillCellId(row.id, colId))]);
+            if (spilled) value = spilled.value;
+            else if (stored && (plain || !stored.explicitNumberFormat)) value = stored.value;
+            else if (plain) value = "";
+            else value = this.cellOf(row, col).value;
+          }
         }
-        results.push(_nullishCoalesce(this.getCell(row.id, col.id).value, () => ( "")));
+        if (value === void 0 || value === null) value = "";
+        if (skipBlanks && value === "") continue;
+        results.push(value);
       }
     }
+    if (cacheable) this.rangeCache.set(cacheKey, { sheet: this.document.id, c0: minC, c1: maxC, values: results.slice() });
     return results;
   }
   resolveCurrentRowProperty(prop) {
-    const rowIndex = _nullishCoalesce(this.evaluatingRowIndex, () => ( _optionalChain([this, 'access', _142 => _142.activeCell, 'optionalAccess', _143 => _143.row])));
+    const rowIndex = _nullishCoalesce(this.evaluatingRowIndex, () => ( _optionalChain([this, 'access', _178 => _178.activeCell, 'optionalAccess', _179 => _179.row])));
     if (rowIndex === void 0 || rowIndex === null) return 0;
     const row = this.document.rows[rowIndex];
     if (!row || !row.recordId || !this.primaryDataSourceId) return 0;
@@ -3368,8 +3888,8 @@ var SpreadsheetController = (_class4 = class {
     this.activeCell = {
       row: activeRow,
       col: activeCol,
-      rowId: _optionalChain([rowObj, 'optionalAccess', _144 => _144.id]),
-      colId: _optionalChain([colObj, 'optionalAccess', _145 => _145.id])
+      rowId: _optionalChain([rowObj, 'optionalAccess', _180 => _180.id]),
+      colId: _optionalChain([colObj, 'optionalAccess', _181 => _181.id])
     };
     if (extendSelection && this.selectedRange) {
       this.selectedRange = this.expandRangeToMerges({
@@ -3388,16 +3908,16 @@ var SpreadsheetController = (_class4 = class {
         endCol: clampedCol
       };
     }
-    _optionalChain([this, 'access', _146 => _146.onSelectionChange, 'optionalCall', _147 => _147(this.activeCell, this.selectedRange)]);
+    _optionalChain([this, 'access', _182 => _182.onSelectionChange, 'optionalCall', _183 => _183(this.activeCell, this.selectedRange)]);
   }
   selectRange(range) {
     this.selectedRange = range;
-    _optionalChain([this, 'access', _148 => _148.onSelectionChange, 'optionalCall', _149 => _149(this.activeCell, this.selectedRange)]);
+    _optionalChain([this, 'access', _184 => _184.onSelectionChange, 'optionalCall', _185 => _185(this.activeCell, this.selectedRange)]);
   }
   startEditing(row, col, initialValue) {
-    this.selectCell(_nullishCoalesce(_nullishCoalesce(row, () => ( _optionalChain([this, 'access', _150 => _150.activeCell, 'optionalAccess', _151 => _151.row]))), () => ( 0)), _nullishCoalesce(_nullishCoalesce(col, () => ( _optionalChain([this, 'access', _152 => _152.activeCell, 'optionalAccess', _153 => _153.col]))), () => ( 0)));
-    const targetRow = _nullishCoalesce(_optionalChain([this, 'access', _154 => _154.activeCell, 'optionalAccess', _155 => _155.row]), () => ( 0));
-    const targetCol = _nullishCoalesce(_optionalChain([this, 'access', _156 => _156.activeCell, 'optionalAccess', _157 => _157.col]), () => ( 0));
+    this.selectCell(_nullishCoalesce(_nullishCoalesce(row, () => ( _optionalChain([this, 'access', _186 => _186.activeCell, 'optionalAccess', _187 => _187.row]))), () => ( 0)), _nullishCoalesce(_nullishCoalesce(col, () => ( _optionalChain([this, 'access', _188 => _188.activeCell, 'optionalAccess', _189 => _189.col]))), () => ( 0)));
+    const targetRow = _nullishCoalesce(_optionalChain([this, 'access', _190 => _190.activeCell, 'optionalAccess', _191 => _191.row]), () => ( 0));
+    const targetCol = _nullishCoalesce(_optionalChain([this, 'access', _192 => _192.activeCell, 'optionalAccess', _193 => _193.col]), () => ( 0));
     const rowObj = this.document.rows[targetRow];
     const colObj = this.document.columns[targetCol];
     if (!rowObj || !colObj) return;
@@ -3438,8 +3958,8 @@ var SpreadsheetController = (_class4 = class {
    */
   commitCellInput(rowId, colId, raw) {
     if (this.validationPrompt) return { status: "pending", prompt: this.validationPrompt };
-    const row = this.document.rows.findIndex((r) => r.id === rowId);
-    const col = this.document.columns.findIndex((c) => c.id === colId);
+    const row = positionOf(this.document.rows, rowId);
+    const col = positionOf(this.document.columns, colId);
     if (row === -1 || col === -1) return { status: "none" };
     const failed = this.checkInput(rowId, colId, row, col, raw, false);
     if (failed) return failed;
@@ -3448,7 +3968,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Validates input; when it fails, records and returns the prompt. */
   checkInput(rowId, colId, row, col, raw, editing) {
-    if (!_optionalChain([this, 'access', _158 => _158.document, 'access', _159 => _159.table, 'optionalAccess', _160 => _160.dataValidations, 'optionalAccess', _161 => _161.length])) return null;
+    if (!_optionalChain([this, 'access', _194 => _194.document, 'access', _195 => _195.table, 'optionalAccess', _196 => _196.dataValidations, 'optionalAccess', _197 => _197.length])) return null;
     if (this.getCell(rowId, colId).raw === raw) return null;
     const result = this.validateCellInput(row, col, raw);
     if (result.valid) return null;
@@ -3465,7 +3985,7 @@ var SpreadsheetController = (_class4 = class {
     const prompt = this.validationPrompt;
     if (!prompt) return;
     this.validationPrompt = null;
-    const editingSameCell = prompt.editing && _optionalChain([this, 'access', _162 => _162.editingCell, 'optionalAccess', _163 => _163.rowId]) === prompt.rowId && _optionalChain([this, 'access', _164 => _164.editingCell, 'optionalAccess', _165 => _165.colId]) === prompt.colId;
+    const editingSameCell = prompt.editing && _optionalChain([this, 'access', _198 => _198.editingCell, 'optionalAccess', _199 => _199.rowId]) === prompt.rowId && _optionalChain([this, 'access', _200 => _200.editingCell, 'optionalAccess', _201 => _201.colId]) === prompt.colId;
     if (action === "accept" && prompt.result.errorStyle !== "stop") {
       this.setCellValue(prompt.rowId, prompt.colId, prompt.raw);
       if (editingSameCell) {
@@ -3512,18 +4032,18 @@ var SpreadsheetController = (_class4 = class {
   // --- Grid Structure Mutations ---
   insertColumn(index, config) {
     this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _166 => _166.id]) || this.generateId("col");
+    const newId = _optionalChain([config, 'optionalAccess', _202 => _202.id]) || this.generateId("col");
     const newCol = {
       id: newId,
-      key: _chunkC7P22VIPcjs.indexToColName.call(void 0, index),
-      title: _optionalChain([config, 'optionalAccess', _167 => _167.title]) || _chunkC7P22VIPcjs.indexToColName.call(void 0, index),
-      width: _optionalChain([config, 'optionalAccess', _168 => _168.width]) || 130,
-      type: _optionalChain([config, 'optionalAccess', _169 => _169.type]) || "freeform",
-      binding: _optionalChain([config, 'optionalAccess', _170 => _170.binding]),
-      formula: _optionalChain([config, 'optionalAccess', _171 => _171.formula]),
-      format: _optionalChain([config, 'optionalAccess', _172 => _172.format]) || "text",
-      ..._optionalChain([config, 'optionalAccess', _173 => _173.numberFormat]) ? { numberFormat: config.numberFormat } : {},
-      readOnly: _optionalChain([config, 'optionalAccess', _174 => _174.readOnly])
+      key: _chunkEWCOFSCQcjs.indexToColName.call(void 0, index),
+      title: _optionalChain([config, 'optionalAccess', _203 => _203.title]) || _chunkEWCOFSCQcjs.indexToColName.call(void 0, index),
+      width: _optionalChain([config, 'optionalAccess', _204 => _204.width]) || 130,
+      type: _optionalChain([config, 'optionalAccess', _205 => _205.type]) || "freeform",
+      binding: _optionalChain([config, 'optionalAccess', _206 => _206.binding]),
+      formula: _optionalChain([config, 'optionalAccess', _207 => _207.formula]),
+      format: _optionalChain([config, 'optionalAccess', _208 => _208.format]) || "text",
+      ..._optionalChain([config, 'optionalAccess', _209 => _209.numberFormat]) ? { numberFormat: config.numberFormat } : {},
+      readOnly: _optionalChain([config, 'optionalAccess', _210 => _210.readOnly])
     };
     this.shiftReferences({ axis: "col", index, type: "insert" });
     this.adjustTableForStructuralChange({ axis: "col", index, type: "insert" });
@@ -3548,13 +4068,13 @@ var SpreadsheetController = (_class4 = class {
   }
   insertRow(index, config) {
     this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _175 => _175.id]) || this.generateId("row");
+    const newId = _optionalChain([config, 'optionalAccess', _211 => _211.id]) || this.generateId("row");
     const newRow = {
       id: newId,
       index,
-      height: _optionalChain([config, 'optionalAccess', _176 => _176.height]) || 32,
-      recordId: _optionalChain([config, 'optionalAccess', _177 => _177.recordId]),
-      type: _optionalChain([config, 'optionalAccess', _178 => _178.type]) || "freeform"
+      height: _optionalChain([config, 'optionalAccess', _212 => _212.height]) || 32,
+      recordId: _optionalChain([config, 'optionalAccess', _213 => _213.recordId]),
+      type: _optionalChain([config, 'optionalAccess', _214 => _214.type]) || "freeform"
     };
     this.shiftReferences({ axis: "row", index, type: "insert" });
     this.adjustTableForStructuralChange({ axis: "row", index, type: "insert" });
@@ -3588,14 +4108,14 @@ var SpreadsheetController = (_class4 = class {
       const filter = this.referencesTo(changed, rt);
       for (const rowCells of Object.values(rt.doc.cells)) {
         for (const cell of Object.values(rowCells)) {
-          if (_optionalChain([cell, 'access', _179 => _179.raw, 'optionalAccess', _180 => _180.startsWith, 'call', _181 => _181("=")])) {
+          if (_optionalChain([cell, 'access', _215 => _215.raw, 'optionalAccess', _216 => _216.startsWith, 'call', _217 => _217("=")])) {
             cell.raw = shiftFormulaReferences(cell.raw, change, filter);
           }
         }
       }
       if (change.axis === "col") {
         for (const col of rt.doc.columns) {
-          if (_optionalChain([col, 'access', _182 => _182.formula, 'optionalAccess', _183 => _183.startsWith, 'call', _184 => _184("=")])) {
+          if (_optionalChain([col, 'access', _218 => _218.formula, 'optionalAccess', _219 => _219.startsWith, 'call', _220 => _220("=")])) {
             col.formula = shiftFormulaReferences(col.formula, change, filter);
           }
         }
@@ -3675,7 +4195,7 @@ var SpreadsheetController = (_class4 = class {
       this.document.rows.push({ id: this.generateId("row"), index, height: 32, type: "freeform" });
     }
     while (colIndex >= this.document.columns.length) {
-      const key = _chunkC7P22VIPcjs.indexToColName.call(void 0, this.document.columns.length);
+      const key = _chunkEWCOFSCQcjs.indexToColName.call(void 0, this.document.columns.length);
       this.document.columns.push({
         id: this.generateId("col"),
         key,
@@ -3708,6 +4228,8 @@ var SpreadsheetController = (_class4 = class {
    */
   runBatch(fn) {
     this.recordSnapshot();
+    const rowCount = this.document.rows.length;
+    const colCount = this.document.columns.length;
     this.batching = true;
     this.pendingCommits = [];
     try {
@@ -3715,14 +4237,20 @@ var SpreadsheetController = (_class4 = class {
     } finally {
       this.batching = false;
     }
+    const grew = this.document.rows.length !== rowCount || this.document.columns.length !== colCount;
     this.recomputeRowIndices();
-    this.recalculateAll();
+    if (grew) {
+      this.recalculateAll();
+    } else {
+      this.cfDirty = "all";
+      this.recalculateWrittenCells(this.pendingCommits.map(([rowId, colId]) => [rowId, colId]));
+    }
     this.document.updatedAt = Date.now();
     this.notifyChange();
     const commits = this.pendingCommits;
     this.pendingCommits = [];
     for (const [rowId, colId, raw] of commits) {
-      _optionalChain([this, 'access', _185 => _185.onCellCommit, 'optionalCall', _186 => _186(rowId, colId, raw, _optionalChain([this, 'access', _187 => _187.document, 'access', _188 => _188.cells, 'access', _189 => _189[rowId], 'optionalAccess', _190 => _190[colId], 'optionalAccess', _191 => _191.value]))]);
+      _optionalChain([this, 'access', _221 => _221.onCellCommit, 'optionalCall', _222 => _222(rowId, colId, raw, _optionalChain([this, 'access', _223 => _223.document, 'access', _224 => _224.cells, 'access', _225 => _225[rowId], 'optionalAccess', _226 => _226[colId], 'optionalAccess', _227 => _227.value]))]);
     }
   }
   // --- CSV ---
@@ -3821,7 +4349,7 @@ var SpreadsheetController = (_class4 = class {
       const r = normalizeRange(this.selectedRange);
       return { row: r.startRow, col: r.startCol };
     }
-    return { row: _nullishCoalesce(_optionalChain([this, 'access', _192 => _192.activeCell, 'optionalAccess', _193 => _193.row]), () => ( 0)), col: _nullishCoalesce(_optionalChain([this, 'access', _194 => _194.activeCell, 'optionalAccess', _195 => _195.col]), () => ( 0)) };
+    return { row: _nullishCoalesce(_optionalChain([this, 'access', _228 => _228.activeCell, 'optionalAccess', _229 => _229.row]), () => ( 0)), col: _nullishCoalesce(_optionalChain([this, 'access', _230 => _230.activeCell, 'optionalAccess', _231 => _231.col]), () => ( 0)) };
   }
   // --- Table operations: shared helpers ---
   /** The table settings object, created on first use. */
@@ -3845,7 +4373,7 @@ var SpreadsheetController = (_class4 = class {
     const { headerRows, footerRows } = getTableSections(this.document);
     return { start: headerRows, end: this.document.rows.length - footerRows - 1 };
   }
-  __init35() {this.getCellValueAt = (rowIndex, colIndex) => {
+  __init51() {this.getCellValueAt = (rowIndex, colIndex) => {
     const row = this.document.rows[rowIndex];
     const col = this.document.columns[colIndex];
     if (!row || !col) return "";
@@ -3858,7 +4386,7 @@ var SpreadsheetController = (_class4 = class {
       const filter = this.referencesTo(moved, rt);
       for (const rowCells of Object.values(rt.doc.cells)) {
         for (const cell of Object.values(rowCells)) {
-          if (_optionalChain([cell, 'access', _196 => _196.raw, 'optionalAccess', _197 => _197.startsWith, 'call', _198 => _198("=")])) {
+          if (_optionalChain([cell, 'access', _232 => _232.raw, 'optionalAccess', _233 => _233.startsWith, 'call', _234 => _234("=")])) {
             cell.raw = remapFormulaReferences(cell.raw, moveCell, filter);
           }
         }
@@ -3872,8 +4400,8 @@ var SpreadsheetController = (_class4 = class {
    */
   adjustTableForStructuralChange(change) {
     this.adjustRulesForStructuralChange(change);
-    const merges = _optionalChain([this, 'access', _199 => _199.document, 'access', _200 => _200.table, 'optionalAccess', _201 => _201.merges]);
-    if (!_optionalChain([merges, 'optionalAccess', _202 => _202.length])) return;
+    const merges = _optionalChain([this, 'access', _235 => _235.document, 'access', _236 => _236.table, 'optionalAccess', _237 => _237.merges]);
+    if (!_optionalChain([merges, 'optionalAccess', _238 => _238.length])) return;
     const startKey = change.axis === "row" ? "startRow" : "startCol";
     const endKey = change.axis === "row" ? "endRow" : "endCol";
     const next = [];
@@ -3904,8 +4432,8 @@ var SpreadsheetController = (_class4 = class {
     const colCount = this.document.columns.length;
     const body = this.getBodyRowBounds();
     const range = options.range ? normalizeRange(options.range) : null;
-    const startRow = Math.max(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _203 => _203.startRow]), () => ( body.start)), body.start);
-    const endRow = Math.min(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _204 => _204.endRow]), () => ( body.end)), body.end);
+    const startRow = Math.max(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _239 => _239.startRow]), () => ( body.start)), body.start);
+    const endRow = Math.min(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _240 => _240.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;
@@ -3915,7 +4443,7 @@ var SpreadsheetController = (_class4 = class {
     }));
     if (keyCols.length === 0 || keyCols.some((k) => k.index < startCol || k.index > endCol)) return false;
     const area = { startRow, startCol, endRow, endCol };
-    if ((_nullishCoalesce(_optionalChain([this, 'access', _205 => _205.document, 'access', _206 => _206.table, 'optionalAccess', _207 => _207.merges]), () => ( []))).some((m) => rangesIntersect(m, area))) return false;
+    if ((_nullishCoalesce(_optionalChain([this, 'access', _241 => _241.document, 'access', _242 => _242.table, 'optionalAccess', _243 => _243.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);
@@ -3943,7 +4471,7 @@ var SpreadsheetController = (_class4 = class {
         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) => _optionalChain([this, 'access', _208 => _208.document, 'access', _209 => _209.cells, 'access', _210 => _210[rowId], 'optionalAccess', _211 => _211[colId]]));
+          return colIds.map((colId) => _optionalChain([this, 'access', _244 => _244.document, 'access', _245 => _245.cells, 'access', _246 => _246[rowId], 'optionalAccess', _247 => _247[colId]]));
         });
         snapshot.forEach((cells, i) => {
           const rowId = this.document.rows[startRow + i].id;
@@ -3959,7 +4487,7 @@ var SpreadsheetController = (_class4 = class {
   }
   // --- Filters ---
   getFilterState() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _212 => _212.document, 'access', _213 => _213.table, 'optionalAccess', _214 => _214.filter]), () => ( { enabled: false, rules: [] }));
+    return _nullishCoalesce(_optionalChain([this, 'access', _248 => _248.document, 'access', _249 => _249.table, 'optionalAccess', _250 => _250.filter]), () => ( { enabled: false, rules: [] }));
   }
   /** Replaces all filter rules (and turns filters on when there are any). */
   setFilterRules(rules) {
@@ -4036,7 +4564,7 @@ var SpreadsheetController = (_class4 = class {
   }
   setTableCount(key, count, max) {
     const value = Math.max(0, Math.min(Math.floor(count), max));
-    if ((_nullishCoalesce(_optionalChain([this, 'access', _215 => _215.document, 'access', _216 => _216.table, 'optionalAccess', _217 => _217[key]]), () => ( 0))) === value) return;
+    if ((_nullishCoalesce(_optionalChain([this, 'access', _251 => _251.document, 'access', _252 => _252.table, 'optionalAccess', _253 => _253[key]]), () => ( 0))) === value) return;
     this.applyTableChange(() => {
       this.table[key] = value;
     });
@@ -4066,7 +4594,7 @@ var SpreadsheetController = (_class4 = class {
         const cells = this.document.cells[row.id] ??= {};
         const existing = cells[col.id];
         if (code === null) {
-          if (!_optionalChain([existing, 'optionalAccess', _218 => _218.explicitNumberFormat])) continue;
+          if (!_optionalChain([existing, 'optionalAccess', _254 => _254.explicitNumberFormat])) continue;
           if (existing.raw === "" && existing.value === "" && !existing.error) {
             delete cells[col.id];
           } else {
@@ -4076,7 +4604,7 @@ var SpreadsheetController = (_class4 = class {
         } else {
           cells[col.id] = {
             ..._nullishCoalesce(existing, () => ( { raw: "", value: "" })),
-            format: _nullishCoalesce(_nullishCoalesce(kind, () => ( _optionalChain([existing, 'optionalAccess', _219 => _219.format]))), () => ( col.format)),
+            format: _nullishCoalesce(_nullishCoalesce(kind, () => ( _optionalChain([existing, 'optionalAccess', _255 => _255.format]))), () => ( col.format)),
             numberFormat: code,
             explicitNumberFormat: true
           };
@@ -4102,7 +4630,7 @@ var SpreadsheetController = (_class4 = class {
     else col.numberFormat = code;
     for (const row of this.document.rows) {
       const cells = this.document.cells[row.id];
-      const cell = _optionalChain([cells, 'optionalAccess', _220 => _220[col.id]]);
+      const cell = _optionalChain([cells, 'optionalAccess', _256 => _256[col.id]]);
       if (cells && cell && !cell.explicitNumberFormat) {
         cells[col.id] = this.withNumberFormat(cell, this.implicitNumberFormat(cell, col, row));
       }
@@ -4114,7 +4642,7 @@ var SpreadsheetController = (_class4 = class {
   /** 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 _nullishCoalesce(this.fixedNumberFormat(col, void 0), () => ( (typed ? _chunkC7P22VIPcjs.parseCellInput.call(void 0, cell.raw).numberFormat : void 0)));
+    return _nullishCoalesce(this.fixedNumberFormat(col, void 0), () => ( (typed ? _chunkEWCOFSCQcjs.parseCellInput.call(void 0, cell.raw).numberFormat : void 0)));
   }
   /** A copy of `cell` with `numberFormat` set, or removed when undefined. */
   withNumberFormat(cell, numberFormat) {
@@ -4127,7 +4655,7 @@ var SpreadsheetController = (_class4 = class {
     const spilled = this.spillCells.get(id);
     if (!spilled) return;
     const { numberFormat: _old, explicitNumberFormat: _explicit, ...rest } = spilled;
-    this.spillCells.set(id, { ...rest, ...this.fixedNumberFormatFields(col, _optionalChain([this, 'access', _221 => _221.document, 'access', _222 => _222.cells, 'access', _223 => _223[row.id], 'optionalAccess', _224 => _224[col.id]])) });
+    this.spillCells.set(id, { ...rest, ...this.fixedNumberFormatFields(col, _optionalChain([this, 'access', _257 => _257.document, 'access', _258 => _258.cells, 'access', _259 => _259[row.id], 'optionalAccess', _260 => _260[col.id]])) });
   }
   // --- Hide / unhide ---
   hideRows(indices) {
@@ -4165,7 +4693,7 @@ var SpreadsheetController = (_class4 = class {
   }
   // --- Merged cells ---
   getMerges() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _225 => _225.document, 'access', _226 => _226.table, 'optionalAccess', _227 => _227.merges]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _261 => _261.document, 'access', _262 => _262.table, 'optionalAccess', _263 => _263.merges]), () => ( []));
   }
   /** The merge containing (row, col), or null. */
   getMergeAt(row, col) {
@@ -4218,7 +4746,7 @@ var SpreadsheetController = (_class4 = class {
         const rowId = this.document.rows[row].id;
         for (let col = r.startCol; col <= r.endCol; col++) {
           if (row === r.startRow && col === r.startCol) continue;
-           _optionalChainDelete([this, 'access', _228 => _228.document, 'access', _229 => _229.cells, 'access', _230 => _230[rowId], 'optionalAccess', _231 => _231[this.document.columns[col].id]]);
+           _optionalChainDelete([this, 'access', _264 => _264.document, 'access', _265 => _265.cells, 'access', _266 => _266[rowId], 'optionalAccess', _267 => _267[this.document.columns[col].id]]);
         }
       }
       this.table.merges = [...merges.filter((m) => !rangeContainsRange(r, m)), r];
@@ -4304,14 +4832,14 @@ var SpreadsheetController = (_class4 = class {
     });
   }
   ungroupRows() {
-    if (!_optionalChain([this, 'access', _232 => _232.document, 'access', _233 => _233.table, 'optionalAccess', _234 => _234.grouping])) return;
+    if (!_optionalChain([this, 'access', _268 => _268.document, 'access', _269 => _269.table, 'optionalAccess', _270 => _270.grouping])) return;
     this.applyTableChange(() => {
       delete this.table.grouping;
     });
   }
   /** Sets (or with `null`, removes) the group summary for a column. */
   setGroupSummary(colId, aggregate) {
-    const grouping = _optionalChain([this, 'access', _235 => _235.document, 'access', _236 => _236.table, 'optionalAccess', _237 => _237.grouping]);
+    const grouping = _optionalChain([this, 'access', _271 => _271.document, 'access', _272 => _272.table, 'optionalAccess', _273 => _273.grouping]);
     if (!grouping) return;
     this.applyTableChange(() => {
       const others = grouping.summaries.filter((s) => s.colId !== colId);
@@ -4322,7 +4850,7 @@ var SpreadsheetController = (_class4 = class {
     });
   }
   setGroupCollapsed(key, collapsed) {
-    const grouping = _optionalChain([this, 'access', _238 => _238.document, 'access', _239 => _239.table, 'optionalAccess', _240 => _240.grouping]);
+    const grouping = _optionalChain([this, 'access', _274 => _274.document, 'access', _275 => _275.table, 'optionalAccess', _276 => _276.grouping]);
     if (!grouping || grouping.collapsed.includes(key) === collapsed) return;
     this.applyTableChange(() => {
       this.table.grouping = {
@@ -4332,7 +4860,7 @@ var SpreadsheetController = (_class4 = class {
     });
   }
   toggleGroupCollapsed(key) {
-    const grouping = _optionalChain([this, 'access', _241 => _241.document, 'access', _242 => _242.table, 'optionalAccess', _243 => _243.grouping]);
+    const grouping = _optionalChain([this, 'access', _277 => _277.document, 'access', _278 => _278.table, 'optionalAccess', _279 => _279.grouping]);
     if (!grouping) return;
     this.setGroupCollapsed(key, !grouping.collapsed.includes(key));
   }
@@ -4370,9 +4898,9 @@ var SpreadsheetController = (_class4 = class {
           moved.push({
             row: s.startRow + (c - s.startCol),
             col: s.startCol + (r - s.startRow),
-            cell: _optionalChain([this, 'access', _244 => _244.document, 'access', _245 => _245.cells, 'access', _246 => _246[rowId(r)], 'optionalAccess', _247 => _247[colId(c)]])
+            cell: _optionalChain([this, 'access', _280 => _280.document, 'access', _281 => _281.cells, 'access', _282 => _282[rowId(r)], 'optionalAccess', _283 => _283[colId(c)]])
           });
-           _optionalChainDelete([this, 'access', _248 => _248.document, 'access', _249 => _249.cells, 'access', _250 => _250[rowId(r)], 'optionalAccess', _251 => _251[colId(c)]]);
+           _optionalChainDelete([this, 'access', _284 => _284.document, 'access', _285 => _285.cells, 'access', _286 => _286[rowId(r)], 'optionalAccess', _287 => _287[colId(c)]]);
         }
       }
       for (const { row, col, cell } of moved) {
@@ -4404,7 +4932,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** A sheet's document by id or name (live: don't mutate it directly). */
   getSheetDocument(idOrName) {
-    return _optionalChain([this, 'access', _252 => _252.findRuntime, 'call', _253 => _253(idOrName), 'optionalAccess', _254 => _254.doc]);
+    return _optionalChain([this, 'access', _288 => _288.findRuntime, 'call', _289 => _289(idOrName), 'optionalAccess', _290 => _290.doc]);
   }
   /** Why `name` can't name a sheet (or null): see `validateSheetName`. `exceptSheet` is the sheet being renamed. */
   validateSheetName(name, exceptSheet) {
@@ -4438,8 +4966,8 @@ var SpreadsheetController = (_class4 = class {
     this.selectedRange = rt.selectedRange;
     this.editingCell = null;
     this.draftValue = "";
-    _optionalChain([this, 'access', _255 => _255.onSelectionChange, 'optionalCall', _256 => _256(this.activeCell, this.selectedRange)]);
-    _optionalChain([this, 'access', _257 => _257.onActiveSheetChange, 'optionalCall', _258 => _258(rt.doc.id)]);
+    _optionalChain([this, 'access', _291 => _291.onSelectionChange, 'optionalCall', _292 => _292(this.activeCell, this.selectedRange)]);
+    _optionalChain([this, 'access', _293 => _293.onActiveSheetChange, 'optionalCall', _294 => _294(rt.doc.id)]);
   }
   /**
    * Adds a sheet (default: `Sheet N`, empty, after the last sheet) and
@@ -4448,16 +4976,16 @@ var SpreadsheetController = (_class4 = class {
    */
   addSheet(options = {}) {
     const existing = this.runtimes.map((rt2) => rt2.doc.name);
-    const name = _nullishCoalesce(_nullishCoalesce(options.name, () => ( _optionalChain([options, 'access', _259 => _259.document, 'optionalAccess', _260 => _260.name]))), () => ( nextSheetName(existing)));
+    const name = _nullishCoalesce(_nullishCoalesce(options.name, () => ( _optionalChain([options, 'access', _295 => _295.document, 'optionalAccess', _296 => _296.name]))), () => ( nextSheetName(existing)));
     const invalid2 = validateSheetName(name, existing);
     if (invalid2) throw new Error(invalid2);
     this.recordWorkbookSnapshot();
-    const id = _optionalChain([options, 'access', _261 => _261.document, 'optionalAccess', _262 => _262.id]) && !this.findRuntimeById(options.document.id) ? options.document.id : this.generateSheetId();
+    const id = _optionalChain([options, 'access', _297 => _297.document, 'optionalAccess', _298 => _298.id]) && !this.findRuntimeById(options.document.id) ? options.document.id : this.generateSheetId();
     const doc = {
       columns: Array.from({ length: 4 }, (_, i) => ({
         id: `col_${String.fromCharCode(97 + i)}`,
-        key: _chunkC7P22VIPcjs.indexToColName.call(void 0, i),
-        title: _chunkC7P22VIPcjs.indexToColName.call(void 0, i),
+        key: _chunkEWCOFSCQcjs.indexToColName.call(void 0, i),
+        title: _chunkEWCOFSCQcjs.indexToColName.call(void 0, i),
         width: 120,
         type: "freeform"
       })),
@@ -4571,13 +5099,13 @@ var SpreadsheetController = (_class4 = class {
     for (const rt of this.runtimes) {
       for (const [rowId, rowCells] of Object.entries(rt.doc.cells)) {
         for (const [colId, cell] of Object.entries(rowCells)) {
-          if (!_optionalChain([cell, 'access', _263 => _263.raw, 'optionalAccess', _264 => _264.startsWith, 'call', _265 => _265("=")])) continue;
+          if (!_optionalChain([cell, 'access', _299 => _299.raw, 'optionalAccess', _300 => _300.startsWith, 'call', _301 => _301("=")])) continue;
           const raw = rewrite(cell.raw);
           if (raw !== cell.raw) rt.doc.cells[rowId][colId] = { ...cell, raw };
         }
       }
       for (const col of rt.doc.columns) {
-        if (_optionalChain([col, 'access', _266 => _266.formula, 'optionalAccess', _267 => _267.startsWith, 'call', _268 => _268("=")])) col.formula = rewrite(col.formula);
+        if (_optionalChain([col, 'access', _302 => _302.formula, 'optionalAccess', _303 => _303.startsWith, 'call', _304 => _304("=")])) col.formula = rewrite(col.formula);
       }
     }
     for (const n of this.names) n.refersTo = rewrite(n.refersTo);
@@ -4599,8 +5127,8 @@ var SpreadsheetController = (_class4 = class {
   }
   /** The defined name `name` visible from the active sheet (its own sheet-scoped name first), or undefined. */
   getName(name, scope) {
-    const rt = _optionalChain([scope, 'optionalAccess', _269 => _269.sheet]) !== void 0 ? this.findRuntime(scope.sheet) : void 0;
-    const def = _optionalChain([scope, 'optionalAccess', _270 => _270.sheet]) !== void 0 ? rt ? this.names.find((n) => n.sheetId === rt.doc.id && sameName3(n.name, name)) : void 0 : this.findName(name, this.active);
+    const rt = _optionalChain([scope, 'optionalAccess', _305 => _305.sheet]) !== void 0 ? this.findRuntime(scope.sheet) : void 0;
+    const def = _optionalChain([scope, 'optionalAccess', _306 => _306.sheet]) !== void 0 ? rt ? this.names.find((n) => n.sheetId === rt.doc.id && sameName3(n.name, name)) : void 0 : this.findName(name, this.active);
     return def ? this.getNames().find((n) => n.name === def.name && n.sheetId === def.sheetId) : void 0;
   }
   /** Why `name` can't be a defined name (or null): see `validateDefinedName`. */
@@ -4608,7 +5136,7 @@ var SpreadsheetController = (_class4 = class {
     return validateDefinedName(name);
   }
   scopeRuntime(scope) {
-    if (_optionalChain([scope, 'optionalAccess', _271 => _271.sheet]) === void 0) return void 0;
+    if (_optionalChain([scope, 'optionalAccess', _307 => _307.sheet]) === void 0) return void 0;
     const rt = this.findRuntime(scope.sheet);
     if (!rt) throw new Error(`There is no sheet "${scope.sheet}".`);
     return rt;
@@ -4625,13 +5153,13 @@ var SpreadsheetController = (_class4 = class {
     if (invalid2) throw new Error(invalid2);
     const formula = refersTo.trim().startsWith("=") ? refersTo.trim() : `=${refersTo.trim()}`;
     try {
-      _chunkC7P22VIPcjs.parseFormula.call(void 0, formula);
+      _chunkEWCOFSCQcjs.parseFormula.call(void 0, formula);
     } catch (err) {
-      throw new Error(`There's a problem with this formula: ${_nullishCoalesce(_optionalChain([err, 'optionalAccess', _272 => _272.message]), () => ( formula))}`);
+      throw new Error(`There's a problem with this formula: ${_nullishCoalesce(_optionalChain([err, 'optionalAccess', _308 => _308.message]), () => ( formula))}`);
     }
     const rt = this.scopeRuntime(options);
     this.recordWorkbookSnapshot();
-    const sheetId = _optionalChain([rt, 'optionalAccess', _273 => _273.doc, 'access', _274 => _274.id]);
+    const sheetId = _optionalChain([rt, 'optionalAccess', _309 => _309.doc, 'access', _310 => _310.id]);
     const index = this.names.findIndex((n) => n.sheetId === sheetId && sameName3(n.name, name));
     const def = {
       name,
@@ -4652,7 +5180,7 @@ var SpreadsheetController = (_class4 = class {
    */
   renameName(oldName, newName, options = {}) {
     const rt = this.scopeRuntime(options);
-    const sheetId = _optionalChain([rt, 'optionalAccess', _275 => _275.doc, 'access', _276 => _276.id]);
+    const sheetId = _optionalChain([rt, 'optionalAccess', _311 => _311.doc, 'access', _312 => _312.id]);
     const def = this.names.find((n) => n.sheetId === sheetId && sameName3(n.name, oldName));
     if (!def) throw new Error(`There is no name "${oldName}"${rt ? ` on sheet ${rt.doc.name}` : ""}.`);
     if (def.name === newName) return;
@@ -4663,19 +5191,19 @@ var SpreadsheetController = (_class4 = class {
     }
     this.recordWorkbookSnapshot();
     const shadowedOn = new Set(this.names.filter((n) => n.sheetId !== void 0 && sameName3(n.name, oldName)).map((n) => n.sheetId));
-    const appliesOn = (sheet) => sheetId !== void 0 ? _optionalChain([sheet, 'optionalAccess', _277 => _277.doc, 'access', _278 => _278.id]) === sheetId : !sheet || !shadowedOn.has(sheet.doc.id);
+    const appliesOn = (sheet) => sheetId !== void 0 ? _optionalChain([sheet, 'optionalAccess', _313 => _313.doc, 'access', _314 => _314.id]) === sheetId : !sheet || !shadowedOn.has(sheet.doc.id);
     const appliesToSheetName = (sheetName) => appliesOn(this.findRuntimeByName(sheetName));
     for (const sheet of this.runtimes) {
       const options2 = { appliesTo: appliesToSheetName, qualifiedOnly: !appliesOn(sheet) };
       for (const [rowId, rowCells] of Object.entries(sheet.doc.cells)) {
         for (const [colId, cell] of Object.entries(rowCells)) {
-          if (!_optionalChain([cell, 'access', _279 => _279.raw, 'optionalAccess', _280 => _280.startsWith, 'call', _281 => _281("=")])) continue;
+          if (!_optionalChain([cell, 'access', _315 => _315.raw, 'optionalAccess', _316 => _316.startsWith, 'call', _317 => _317("=")])) continue;
           const raw = renameNameInFormula(cell.raw, oldName, newName, options2);
           if (raw !== cell.raw) sheet.doc.cells[rowId][colId] = { ...cell, raw };
         }
       }
       for (const col of sheet.doc.columns) {
-        if (_optionalChain([col, 'access', _282 => _282.formula, 'optionalAccess', _283 => _283.startsWith, 'call', _284 => _284("=")])) col.formula = renameNameInFormula(col.formula, oldName, newName, options2);
+        if (_optionalChain([col, 'access', _318 => _318.formula, 'optionalAccess', _319 => _319.startsWith, 'call', _320 => _320("=")])) col.formula = renameNameInFormula(col.formula, oldName, newName, options2);
       }
     }
     for (const n of this.names) {
@@ -4695,7 +5223,7 @@ var SpreadsheetController = (_class4 = class {
    */
   deleteName(name, options = {}) {
     const rt = this.scopeRuntime(options);
-    const sheetId = _optionalChain([rt, 'optionalAccess', _285 => _285.doc, 'access', _286 => _286.id]);
+    const sheetId = _optionalChain([rt, 'optionalAccess', _321 => _321.doc, 'access', _322 => _322.id]);
     const index = this.names.findIndex((n) => n.sheetId === sheetId && sameName3(n.name, name));
     if (index < 0) return false;
     this.recordWorkbookSnapshot();
@@ -4742,6 +5270,17 @@ var SpreadsheetController = (_class4 = class {
     if (this.isApplyingHistory || this.batching) return;
     this.pushUndo({ kind: "sheet", sheetId: this.ctx.doc.id, data: JSON.stringify(this.ctx.doc) });
   }
+  /** Records the stored state of one cell, for undoing a single-cell edit. */
+  recordCellSnapshot(rowId, colId) {
+    if (this.isApplyingHistory || this.batching) return;
+    this.pushUndo({ kind: "cells", sheetId: this.ctx.doc.id, data: JSON.stringify(this.cellHistory(this.ctx.doc, [[rowId, colId]])) });
+  }
+  cellHistory(doc, cells) {
+    return {
+      cells: cells.map(([rowId, colId]) => [rowId, colId, _nullishCoalesce(_optionalChain([doc, 'access', _323 => _323.cells, 'access', _324 => _324[rowId], 'optionalAccess', _325 => _325[colId]]), () => ( null)), doc.cells[rowId] !== void 0]),
+      updatedAt: doc.updatedAt
+    };
+  }
   recordWorkbookSnapshot() {
     if (this.isApplyingHistory || this.batching) return;
     this.pushUndo({ kind: "workbook", data: JSON.stringify(this.workbookSnapshot()) });
@@ -4783,6 +5322,37 @@ var SpreadsheetController = (_class4 = class {
     if (!entry) return;
     this.isApplyingHistory = true;
     try {
+      if (entry.kind === "cells") {
+        const rt = this.findRuntimeById(entry.sheetId);
+        if (!rt) return;
+        const saved = JSON.parse(entry.data);
+        const positions = saved.cells.map(([rowId, colId]) => [rowId, colId]);
+        to.push({ kind: "cells", sheetId: rt.doc.id, data: JSON.stringify(this.cellHistory(rt.doc, positions)) });
+        for (const [rowId, colId, cell, rowExisted] of saved.cells) {
+          if (cell) {
+            (rt.doc.cells[rowId] ??= {})[colId] = cell;
+          } else if (rt.doc.cells[rowId]) {
+            delete rt.doc.cells[rowId][colId];
+            if (!rowExisted && Object.keys(rt.doc.cells[rowId]).length === 0) delete rt.doc.cells[rowId];
+          }
+        }
+        if (saved.updatedAt !== void 0) rt.doc.updatedAt = saved.updatedAt;
+        if (rt !== this.active) {
+          this.ctx = this.active;
+          this.activateRuntime(rt);
+        }
+        this.withSheet(rt, () => {
+          for (const [rowId, colId] of positions) {
+            const raw = _optionalChain([rt, 'access', _326 => _326.doc, 'access', _327 => _327.cells, 'access', _328 => _328[rowId], 'optionalAccess', _329 => _329[colId], 'optionalAccess', _330 => _330.raw]);
+            const cellKey2 = this.getCellKey(rowId, colId);
+            this.registerFormula(cellKey2, _optionalChain([raw, 'optionalAccess', _331 => _331.startsWith, 'call', _332 => _332("=")]) ? raw : null);
+            this.dropStaleSpillEdges(cellKey2, _nullishCoalesce(raw, () => ( "")));
+          }
+          this.recalculateWrittenCells(positions);
+        });
+        this.notifyChange();
+        return;
+      }
       if (entry.kind === "sheet") {
         const rt = this.findRuntimeById(entry.sheetId);
         if (!rt) return;
@@ -4811,8 +5381,8 @@ var SpreadsheetController = (_class4 = class {
         } else {
           this.activeCell = this.active.activeCell;
           this.selectedRange = this.active.selectedRange;
-          _optionalChain([this, 'access', _287 => _287.onSelectionChange, 'optionalCall', _288 => _288(this.activeCell, this.selectedRange)]);
-          _optionalChain([this, 'access', _289 => _289.onActiveSheetChange, 'optionalCall', _290 => _290(this.active.doc.id)]);
+          _optionalChain([this, 'access', _333 => _333.onSelectionChange, 'optionalCall', _334 => _334(this.activeCell, this.selectedRange)]);
+          _optionalChain([this, 'access', _335 => _335.onActiveSheetChange, 'optionalCall', _336 => _336(this.active.doc.id)]);
         }
       }
       this.recalculateAll();
@@ -4824,7 +5394,7 @@ var SpreadsheetController = (_class4 = class {
   notifyChange() {
     if (!this.cfIncremental) this.cfDirty = "all";
     this.invalidCircles = null;
-    _optionalChain([this, 'access', _291 => _291.onDocumentChange, 'optionalCall', _292 => _292(this.active.doc)]);
+    _optionalChain([this, 'access', _337 => _337.onDocumentChange, 'optionalCall', _338 => _338(this.active.doc)]);
     if (this.onWorkbookChange) {
       const snapshot = this.workbookSnapshot();
       this.onWorkbookChange({ sheets: snapshot.sheets, activeSheetId: snapshot.activeSheetId, names: snapshot.names });
@@ -4854,7 +5424,7 @@ var SpreadsheetController = (_class4 = class {
   evaluateFormulaAt(formula, row, col, entered) {
     const saved = { rowIndex: this.evaluatingRowIndex, cell: this.evaluatingCell, override: this.valueOverride };
     this.evaluatingRowIndex = row;
-    this.evaluatingCell = { col: _nullishCoalesce(_optionalChain([this, 'access', _293 => _293.document, 'access', _294 => _294.columns, 'access', _295 => _295[col], 'optionalAccess', _296 => _296.key]), () => ( _chunkC7P22VIPcjs.indexToColName.call(void 0, col))), row: row + 1 };
+    this.evaluatingCell = { col: _nullishCoalesce(_optionalChain([this, 'access', _339 => _339.document, 'access', _340 => _340.columns, 'access', _341 => _341[col], 'optionalAccess', _342 => _342.key]), () => ( _chunkEWCOFSCQcjs.indexToColName.call(void 0, col))), row: row + 1 };
     this.valueOverride = _nullishCoalesce(entered, () => ( null));
     try {
       const result = this.evaluator.evaluateWithDiagnostics(formula.startsWith("=") ? formula : `=${formula}`);
@@ -4881,7 +5451,7 @@ var SpreadsheetController = (_class4 = class {
     if (!table) return;
     const shiftIfFormula = (text) => text !== void 0 && text.trimStart().startsWith("=") ? shiftRuleFormula(text, change) : text;
     const shiftAnchor = (value) => value.type === "formula" ? { ...value, formula: shiftRuleFormula(value.formula, change) } : value;
-    if (_optionalChain([table, 'access', _297 => _297.conditionalFormats, 'optionalAccess', _298 => _298.length])) {
+    if (_optionalChain([table, 'access', _343 => _343.conditionalFormats, 'optionalAccess', _344 => _344.length])) {
       table.conditionalFormats = table.conditionalFormats.map((rule) => {
         const next = { ...rule, ranges: adjustRangesForStructuralChange(rule.ranges, change) };
         if (next.type === "expression") next.formula = shiftRuleFormula(next.formula, change);
@@ -4898,7 +5468,7 @@ var SpreadsheetController = (_class4 = class {
         return next;
       }).filter((rule) => rule.ranges.length > 0);
     }
-    if (_optionalChain([table, 'access', _299 => _299.dataValidations, 'optionalAccess', _300 => _300.length])) {
+    if (_optionalChain([table, 'access', _345 => _345.dataValidations, 'optionalAccess', _346 => _346.length])) {
       table.dataValidations = table.dataValidations.map((rule) => {
         const next = { ...rule, ranges: adjustRangesForStructuralChange(rule.ranges, change) };
         if (rule.formula1 !== void 0) next.formula1 = shiftIfFormula(rule.formula1);
@@ -4909,7 +5479,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Conditional formats of the sheet, highest priority first. */
   getConditionalFormats() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _301 => _301.document, 'access', _302 => _302.table, 'optionalAccess', _303 => _303.conditionalFormats]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _347 => _347.document, 'access', _348 => _348.table, 'optionalAccess', _349 => _349.conditionalFormats]), () => ( []));
   }
   /**
    * Adds a conditional format (one undo step). New rules get the highest
@@ -4929,7 +5499,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Changes a conditional format (its condition, ranges or stop-if-true). Returns false when not found. */
   updateConditionalFormat(id, changes) {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _304 => _304.document, 'access', _305 => _305.table, 'optionalAccess', _306 => _306.conditionalFormats]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _350 => _350.document, 'access', _351 => _351.table, 'optionalAccess', _352 => _352.conditionalFormats]), () => ( []));
     const index = rules.findIndex((r) => r.id === id);
     if (index === -1) return false;
     this.applyTableChange(() => {
@@ -4943,7 +5513,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Removes a conditional format. Returns false when not found. */
   deleteConditionalFormat(id) {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _307 => _307.document, 'access', _308 => _308.table, 'optionalAccess', _309 => _309.conditionalFormats]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _353 => _353.document, 'access', _354 => _354.table, 'optionalAccess', _355 => _355.conditionalFormats]), () => ( []));
     if (!rules.some((r) => r.id === id)) return false;
     this.applyTableChange(() => {
       this.table.conditionalFormats = rules.filter((r) => r.id !== id);
@@ -4955,7 +5525,7 @@ var SpreadsheetController = (_class4 = class {
    * `{ by: -1 }` (up) / `{ by: 1 }` (down). Returns false when nothing moved.
    */
   moveConditionalFormat(id, to) {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _310 => _310.document, 'access', _311 => _311.table, 'optionalAccess', _312 => _312.conditionalFormats]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _356 => _356.document, 'access', _357 => _357.table, 'optionalAccess', _358 => _358.conditionalFormats]), () => ( []));
     const from = rules.findIndex((r) => r.id === id);
     if (from === -1) return false;
     const target = Math.max(0, Math.min(rules.length - 1, typeof to === "number" ? to : from + to.by));
@@ -4974,7 +5544,7 @@ var SpreadsheetController = (_class4 = class {
    * when `range` is null.
    */
   clearConditionalFormats(range = null) {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _313 => _313.document, 'access', _314 => _314.table, 'optionalAccess', _315 => _315.conditionalFormats]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _359 => _359.document, 'access', _360 => _360.table, 'optionalAccess', _361 => _361.conditionalFormats]), () => ( []));
     if (rules.length === 0) return;
     this.applyTableChange(() => {
       this.table.conditionalFormats = range ? rules.map((rule) => ({ ...rule, ranges: subtractRangeFromRanges(rule.ranges, range) })).filter((rule) => rule.ranges.length > 0) : [];
@@ -4985,7 +5555,7 @@ var SpreadsheetController = (_class4 = class {
    * cached: after a cell edit only the affected cells are re-evaluated.
    */
   getConditionalFormatOverlay() {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _316 => _316.document, 'access', _317 => _317.table, 'optionalAccess', _318 => _318.conditionalFormats]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _362 => _362.document, 'access', _363 => _363.table, 'optionalAccess', _364 => _364.conditionalFormats]), () => ( []));
     if (rules.length === 0) {
       this.cfEngine = null;
       this.cfDirty = "all";
@@ -4999,7 +5569,7 @@ var SpreadsheetController = (_class4 = class {
       const changed = [];
       for (const key of this.cfDirty) {
         const located = this.locateCellKey(key);
-        if (located) changed.push({ row: located.row.index, col: this.document.columns.indexOf(located.col) });
+        if (located) changed.push({ row: located.row.index, col: positionOf(this.document.columns, located.col.id) });
       }
       this.cfEngine.setSheet(sheet);
       this.cfEngine.update(rules, changed);
@@ -5013,11 +5583,11 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Data validation rules of the sheet. */
   getDataValidations() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _319 => _319.document, 'access', _320 => _320.table, 'optionalAccess', _321 => _321.dataValidations]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _365 => _365.document, 'access', _366 => _366.table, 'optionalAccess', _367 => _367.dataValidations]), () => ( []));
   }
   /** The rule that applies to (row, col), if any. */
   getDataValidationAt(row, col) {
-    return findDataValidation(_optionalChain([this, 'access', _322 => _322.document, 'access', _323 => _323.table, 'optionalAccess', _324 => _324.dataValidations]), row, col);
+    return findDataValidation(_optionalChain([this, 'access', _368 => _368.document, 'access', _369 => _369.table, 'optionalAccess', _370 => _370.dataValidations]), row, col);
   }
   /**
    * Adds a data validation rule (one undo step). Its cells are first
@@ -5037,7 +5607,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Changes a data validation rule. Returns false when not found. */
   updateDataValidation(id, changes) {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _325 => _325.document, 'access', _326 => _326.table, 'optionalAccess', _327 => _327.dataValidations]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _371 => _371.document, 'access', _372 => _372.table, 'optionalAccess', _373 => _373.dataValidations]), () => ( []));
     const index = rules.findIndex((r) => r.id === id);
     if (index === -1) return false;
     this.applyTableChange(() => {
@@ -5051,7 +5621,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Removes a data validation rule. Returns false when not found. */
   deleteDataValidation(id) {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _328 => _328.document, 'access', _329 => _329.table, 'optionalAccess', _330 => _330.dataValidations]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _374 => _374.document, 'access', _375 => _375.table, 'optionalAccess', _376 => _376.dataValidations]), () => ( []));
     if (!rules.some((r) => r.id === id)) return false;
     this.applyTableChange(() => {
       this.table.dataValidations = rules.filter((r) => r.id !== id);
@@ -5060,7 +5630,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Removes validation from the cells of `range`, or every rule when `range` is null. */
   clearDataValidation(range = null) {
-    const rules = _nullishCoalesce(_optionalChain([this, 'access', _331 => _331.document, 'access', _332 => _332.table, 'optionalAccess', _333 => _333.dataValidations]), () => ( []));
+    const rules = _nullishCoalesce(_optionalChain([this, 'access', _377 => _377.document, 'access', _378 => _378.table, 'optionalAccess', _379 => _379.dataValidations]), () => ( []));
     if (rules.length === 0) return;
     this.applyTableChange(() => {
       this.table.dataValidations = range ? rules.map((r) => ({ ...r, ranges: subtractRangeFromRanges(r.ranges, range) })).filter((r) => r.ranges.length > 0) : [];
@@ -5068,7 +5638,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Checks input for (row, col) against its data validation, without committing it. */
   validateCellInput(row, col, raw) {
-    return validateCellInput(this.ruleSheet(), _optionalChain([this, 'access', _334 => _334.document, 'access', _335 => _335.table, 'optionalAccess', _336 => _336.dataValidations]), row, col, raw);
+    return validateCellInput(this.ruleSheet(), _optionalChain([this, 'access', _380 => _380.document, 'access', _381 => _381.table, 'optionalAccess', _382 => _382.dataValidations]), row, col, raw);
   }
   /**
    * Dropdown items of a list-validated cell, or null when the cell has no
@@ -5081,7 +5651,7 @@ var SpreadsheetController = (_class4 = class {
   }
   /** Cells whose current value breaks their validation rule. */
   findInvalidCells() {
-    return findInvalidCells(this.ruleSheet(), _optionalChain([this, 'access', _337 => _337.document, 'access', _338 => _338.table, 'optionalAccess', _339 => _339.dataValidations]));
+    return findInvalidCells(this.ruleSheet(), _optionalChain([this, 'access', _383 => _383.document, 'access', _384 => _384.table, 'optionalAccess', _385 => _385.dataValidations]));
   }
   /**
    * Turns "circle invalid data" on or off. View state, not part of the
@@ -5092,7 +5662,7 @@ var SpreadsheetController = (_class4 = class {
     if (this.circlesShown === show) return;
     this.circlesShown = show;
     this.invalidCircles = null;
-    _optionalChain([this, 'access', _340 => _340.onDocumentChange, 'optionalCall', _341 => _341(this.document)]);
+    _optionalChain([this, 'access', _386 => _386.onDocumentChange, 'optionalCall', _387 => _387(this.document)]);
   }
   /** Whether invalid cells are circled. */
   getInvalidDataCircles() {
@@ -5106,7 +5676,7 @@ var SpreadsheetController = (_class4 = class {
     }
     return this.invalidCircles.has(`${row}:${col}`);
   }
-}, _class4);
+}, _class6);
 function stepInOrder(order, from, delta) {
   if (order.length === 0) return from;
   const pos = order.indexOf(from);
@@ -5155,7 +5725,7 @@ function getSpreadsheetMenuItems(controller, cell) {
   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 = _chunkC7P22VIPcjs.indexToColName.call(void 0, cell.col);
+  const colName = _chunkEWCOFSCQcjs.indexToColName.call(void 0, cell.col);
   const cellData = controller.getCell(row.id, column.id);
   const value = cellData.value;
   const table = _nullishCoalesce(doc.table, () => ( {}));
@@ -5524,7 +6094,7 @@ function getSheetTabMenuItems(controller, sheetId, options = {}) {
       fn();
     } catch (err) {
       if (!options.onError) throw err;
-      options.onError(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _342 => _342.message]), () => ( String(err))));
+      options.onError(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _388 => _388.message]), () => ( String(err))));
     }
   };
   return [
@@ -5592,7 +6162,7 @@ function getNameManagerRows(controller) {
       value = "[LAMBDA]";
     } else {
       const result = controller.evaluateFormula(`=${n.name}`, n.sheetId ? { sheet: n.sheetId } : {});
-      value = result.array ? `{${result.array.rows}\xD7${result.array.cols} array}` : _chunkC7P22VIPcjs.isFormulaError.call(void 0, result.value) ? String(result.value) : formatCellDisplay({ value: result.value });
+      value = result.array ? `{${result.array.rows}\xD7${result.array.cols} array}` : _chunkEWCOFSCQcjs.isFormulaError.call(void 0, result.value) ? String(result.value) : formatCellDisplay({ value: result.value });
     }
     return {
       name: n.name,
@@ -5606,6 +6176,188 @@ function getNameManagerRows(controller) {
   }).sort((a, b) => a.name.localeCompare(b.name) || a.scopeLabel.localeCompare(b.scopeLabel));
 }
 
+// src/spreadsheet/viewport.ts
+var SPREADSHEET_COLUMN_HEADER_HEIGHT = 28;
+var SPREADSHEET_ROW_HEADER_WIDTH = 48;
+var SPREADSHEET_GROUP_ROW_HEIGHT = 28;
+var SPREADSHEET_VIRTUAL_ROW_THRESHOLD = 200;
+var SPREADSHEET_VIRTUAL_COLUMN_THRESHOLD = 60;
+var SPREADSHEET_DEFAULT_VIEWPORT = { width: 1200, height: 600 };
+function measureSpreadsheetView(view) {
+  const rowTops = new Float64Array(view.rows.length + 1);
+  const rowPosition = /* @__PURE__ */ new Map();
+  let frozenRows = 0;
+  let top = 0;
+  view.rows.forEach((viewRow, i) => {
+    rowTops[i] = top;
+    if (viewRow.kind === "row") {
+      rowPosition.set(viewRow.index, i);
+      if (viewRow.frozen && frozenRows === i) frozenRows = i + 1;
+      top += viewRow.row.height || DEFAULT_ROW_HEIGHT;
+    } else {
+      top += SPREADSHEET_GROUP_ROW_HEIGHT;
+    }
+  });
+  rowTops[view.rows.length] = top;
+  const columnLefts = new Float64Array(view.columns.length + 1);
+  const columnPosition = /* @__PURE__ */ new Map();
+  let frozenColumns = 0;
+  let left = 0;
+  view.columns.forEach((viewCol, i) => {
+    columnLefts[i] = left;
+    columnPosition.set(viewCol.index, i);
+    if (viewCol.frozen && frozenColumns === i) frozenColumns = i + 1;
+    left += viewCol.column.width || DEFAULT_COLUMN_WIDTH;
+  });
+  columnLefts[view.columns.length] = left;
+  return { rowTops, columnLefts, frozenRows, frozenColumns, rowPosition, columnPosition };
+}
+function shouldVirtualizeSpreadsheet(view, mode = "auto") {
+  if (mode !== "auto") return mode;
+  return view.rows.length > SPREADSHEET_VIRTUAL_ROW_THRESHOLD || view.columns.length > SPREADSHEET_VIRTUAL_COLUMN_THRESHOLD;
+}
+function fullSpreadsheetViewWindow(metrics) {
+  return {
+    virtual: false,
+    frozenRows: metrics.frozenRows,
+    rowStart: metrics.frozenRows,
+    rowEnd: metrics.rowTops.length - 1,
+    topSpace: 0,
+    bottomSpace: 0,
+    frozenColumns: metrics.frozenColumns,
+    colStart: metrics.frozenColumns,
+    colEnd: metrics.columnLefts.length - 1,
+    leftSpace: 0,
+    rightSpace: 0
+  };
+}
+function entryAt(edges, value, lo, hi) {
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (edges[mid + 1] <= value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function visibleSlice(edges, frozen, from, to, overscan) {
+  const count = edges.length - 1;
+  if (count <= frozen) return [frozen, frozen];
+  const first2 = entryAt(edges, from, frozen, count);
+  const last = entryAt(edges, Math.max(from, to - 1), first2, count);
+  return [Math.max(frozen, first2 - overscan), Math.min(count, last + 1 + overscan)];
+}
+function getSpreadsheetViewWindow(metrics, viewport, options = {}) {
+  const overscanRows = _nullishCoalesce(options.overscanRows, () => ( 8));
+  const overscanColumns = _nullishCoalesce(options.overscanColumns, () => ( 2));
+  const height = viewport.height > 0 ? viewport.height : SPREADSHEET_DEFAULT_VIEWPORT.height;
+  const width = viewport.width > 0 ? viewport.width : SPREADSHEET_DEFAULT_VIEWPORT.width;
+  const { rowTops, columnLefts, frozenRows, frozenColumns } = metrics;
+  const rowCount = rowTops.length - 1;
+  const colCount = columnLefts.length - 1;
+  const top = Math.max(0, viewport.scrollTop);
+  let [rowStart, rowEnd] = visibleSlice(rowTops, frozenRows, top, top + Math.max(0, height - SPREADSHEET_COLUMN_HEADER_HEIGHT), overscanRows);
+  const left = Math.max(0, viewport.scrollLeft);
+  let [colStart, colEnd] = visibleSlice(columnLefts, frozenColumns, left, left + Math.max(0, width - SPREADSHEET_ROW_HEADER_WIDTH), overscanColumns);
+  const merges = _nullishCoalesce(options.merges, () => ( []));
+  for (let changed = merges.length > 0, guard = 0; changed && guard < 8; guard++) {
+    changed = false;
+    for (const raw of merges) {
+      const merge = normalizeRange(raw);
+      const rows = displayedSpan(metrics.rowPosition, merge.startRow, merge.endRow);
+      const cols = displayedSpan(metrics.columnPosition, merge.startCol, merge.endCol);
+      if (!rows || !cols) continue;
+      const rowsMeet = rows[1] >= rowStart && rows[0] < rowEnd;
+      const colsMeet = cols[1] >= colStart && cols[0] < colEnd;
+      if (!rowsMeet && !(rows[1] < frozenRows)) continue;
+      if (!colsMeet && !(cols[1] < frozenColumns)) continue;
+      if (rowsMeet) {
+        const s = Math.max(frozenRows, rows[0]);
+        const e = rows[1] + 1;
+        if (s < rowStart || e > rowEnd) {
+          rowStart = Math.min(rowStart, s);
+          rowEnd = Math.max(rowEnd, e);
+          changed = true;
+        }
+      }
+      if (colsMeet) {
+        const s = Math.max(frozenColumns, cols[0]);
+        const e = cols[1] + 1;
+        if (s < colStart || e > colEnd) {
+          colStart = Math.min(colStart, s);
+          colEnd = Math.max(colEnd, e);
+          changed = true;
+        }
+      }
+    }
+  }
+  return {
+    virtual: true,
+    frozenRows,
+    rowStart,
+    rowEnd,
+    topSpace: rowTops[rowStart] - rowTops[frozenRows],
+    bottomSpace: rowTops[rowCount] - rowTops[rowEnd],
+    frozenColumns,
+    colStart,
+    colEnd,
+    leftSpace: columnLefts[colStart] - columnLefts[frozenColumns],
+    rightSpace: columnLefts[colCount] - columnLefts[colEnd]
+  };
+}
+function displayedSpan(positions, from, to) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (let i = from; i <= to; i++) {
+    const pos = positions.get(i);
+    if (pos === void 0) continue;
+    if (pos < lo) lo = pos;
+    if (pos > hi) hi = pos;
+  }
+  return lo === Infinity ? null : [lo, hi];
+}
+function getSpreadsheetScrollToCell(metrics, viewport, cell) {
+  const height = viewport.height > 0 ? viewport.height : SPREADSHEET_DEFAULT_VIEWPORT.height;
+  const width = viewport.width > 0 ? viewport.width : SPREADSHEET_DEFAULT_VIEWPORT.width;
+  const result = {};
+  const rowPos = metrics.rowPosition.get(cell.row);
+  if (rowPos !== void 0 && rowPos >= metrics.frozenRows) {
+    const frozenHeight = metrics.rowTops[metrics.frozenRows];
+    const top = metrics.rowTops[rowPos];
+    const bottom = metrics.rowTops[rowPos + 1];
+    const visibleHeight = height - SPREADSHEET_COLUMN_HEADER_HEIGHT;
+    if (top < viewport.scrollTop + frozenHeight) result.scrollTop = Math.max(0, top - frozenHeight);
+    else if (bottom > viewport.scrollTop + visibleHeight) result.scrollTop = Math.max(0, bottom - visibleHeight);
+  }
+  const colPos = metrics.columnPosition.get(cell.col);
+  if (colPos !== void 0 && colPos >= metrics.frozenColumns) {
+    const frozenWidth = metrics.columnLefts[metrics.frozenColumns];
+    const left = metrics.columnLefts[colPos];
+    const right = metrics.columnLefts[colPos + 1];
+    const visibleWidth = width - SPREADSHEET_ROW_HEADER_WIDTH;
+    if (left < viewport.scrollLeft + frozenWidth) result.scrollLeft = Math.max(0, left - frozenWidth);
+    else if (right > viewport.scrollLeft + visibleWidth) result.scrollLeft = Math.max(0, right - visibleWidth);
+  }
+  return result.scrollTop === void 0 && result.scrollLeft === void 0 ? null : result;
+}
+function sameSpreadsheetViewWindow(a, b) {
+  return a.virtual === b.virtual && a.rowStart === b.rowStart && a.rowEnd === b.rowEnd && a.colStart === b.colStart && a.colEnd === b.colEnd && a.topSpace === b.topSpace && a.bottomSpace === b.bottomSpace && a.leftSpace === b.leftSpace && a.rightSpace === b.rightSpace;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -5722,5 +6474,5 @@ function getNameManagerRows(controller) {
 
 
 
-exports.extractNameDependencies = extractNameDependencies; exports.columnDependencyKey = columnDependencyKey; exports.extractCellDependencies = extractCellDependencies; exports.DependencyGraph = DependencyGraph; exports.shiftFormulaReferences = shiftFormulaReferences; exports.mapFormulaReferences = mapFormulaReferences; exports.offsetFormulaReferences = offsetFormulaReferences; exports.remapFormulaReferences = remapFormulaReferences; exports.sheetNameNeedsQuotes = sheetNameNeedsQuotes; exports.quoteSheetName = quoteSheetName; exports.formatSheetPrefix = formatSheetPrefix; exports.renameSheetInFormula = renameSheetInFormula; exports.deleteSheetInFormula = deleteSheetInFormula; exports.renameNameInFormula = renameNameInFormula; exports.formulaIdentifiers = formulaIdentifiers; exports.getFormulaCaretContext = getFormulaCaretContext; exports.getFormulaHints = getFormulaHints; exports.applyFormulaSuggestion = applyFormulaSuggestion; exports.NUMBER_FORMAT_PRESETS = NUMBER_FORMAT_PRESETS; exports.numberFormatForCellFormat = numberFormatForCellFormat; exports.cellFormatForNumberFormat = cellFormatForNumberFormat; exports.isGeneralNumberFormat = isGeneralNumberFormat; exports.formatCellForDisplay = formatCellForDisplay; exports.formatCellDisplay = formatCellDisplay; exports.formatValueWithCode = formatValueWithCode; exports.DataSourceBinder = DataSourceBinder; exports.MAX_SHEET_NAME_LENGTH = MAX_SHEET_NAME_LENGTH; exports.MAX_DEFINED_NAME_LENGTH = MAX_DEFINED_NAME_LENGTH; exports.validateSheetName = validateSheetName; exports.nextSheetName = nextSheetName; exports.copySheetName = copySheetName; exports.validateDefinedName = validateDefinedName; exports.isLambdaDefinition = isLambdaDefinition; exports.normalizeRange = normalizeRange; exports.rangeContains = rangeContains; exports.rangesIntersect = rangesIntersect; exports.rangeContainsRange = rangeContainsRange; exports.isSingleCellRange = isSingleCellRange; exports.isBlankValue = isBlankValue; exports.toNumber = toNumber; exports.compareCellValues = compareCellValues; exports.matchesFilterRule = matchesFilterRule; exports.aggregateValues = aggregateValues; exports.roundFloat = roundFloat; exports.fillSeries = fillSeries; exports.computeFillTarget = computeFillTarget; exports.getFillDirection = getFillDirection; exports.SPREADSHEET_CLIPBOARD_MIME = SPREADSHEET_CLIPBOARD_MIME; exports.serializeHtmlTable = serializeHtmlTable; exports.parseHtmlTable = parseHtmlTable; exports.createSpreadsheetClipboardData = createSpreadsheetClipboardData; exports.readSpreadsheetClipboard = readSpreadsheetClipboard; exports.rebaseClipboardRows = rebaseClipboardRows; exports.adjustRangeForStructuralChange = adjustRangeForStructuralChange; exports.adjustRangesForStructuralChange = adjustRangesForStructuralChange; exports.subtractRange = subtractRange; exports.subtractRangeFromRanges = subtractRangeFromRanges; exports.rangesContain = rangesContain; exports.ruleAnchor = ruleAnchor; exports.ruleFormulaAt = ruleFormulaAt; exports.shiftRuleFormula = shiftRuleFormula; exports.forEachRangeCell = forEachRangeCell; exports.formatRuleRanges = formatRuleRanges; exports.parseRuleRanges = parseRuleRanges; exports.CONDITIONAL_FORMAT_ICON_SETS = CONDITIONAL_FORMAT_ICON_SETS; exports.conditionalFormatIconCount = conditionalFormatIconCount; exports.getConditionalFormatIcon = getConditionalFormatIcon; exports.conditionalFormatNumber = conditionalFormatNumber; exports.blendConditionalFormatColors = blendConditionalFormatColors; exports.defaultIconThresholds = defaultIconThresholds; exports.EMPTY_CONDITIONAL_FORMAT_OVERLAY = EMPTY_CONDITIONAL_FORMAT_OVERLAY; exports.ConditionalFormatEngine = ConditionalFormatEngine; exports.matchesTimePeriod = matchesTimePeriod; exports.evaluateConditionalFormats = evaluateConditionalFormats; exports.describeConditionalFormat = describeConditionalFormat; exports.describeDataValidation = describeDataValidation; exports.CONDITIONAL_FORMAT_STYLE_PRESETS = CONDITIONAL_FORMAT_STYLE_PRESETS; exports.DEFAULT_CONDITIONAL_FORMAT_STYLE = DEFAULT_CONDITIONAL_FORMAT_STYLE; exports.CONDITIONAL_FORMAT_PRESETS = CONDITIONAL_FORMAT_PRESETS; exports.CONDITIONAL_FORMAT_TIME_PERIODS = CONDITIONAL_FORMAT_TIME_PERIODS; exports.createConditionalFormatRule = createConditionalFormatRule; exports.DATA_VALIDATION_TYPE_OPTIONS = DATA_VALIDATION_TYPE_OPTIONS; exports.DATA_VALIDATION_OPERATOR_OPTIONS = DATA_VALIDATION_OPERATOR_OPTIONS; exports.DATA_VALIDATION_ERROR_STYLE_OPTIONS = DATA_VALIDATION_ERROR_STYLE_OPTIONS; exports.conditionalFormatContrastColor = conditionalFormatContrastColor; exports.getConditionalFormatCss = getConditionalFormatCss; exports.getDataBarCss = getDataBarCss; exports.conditionalFormatStyleString = conditionalFormatStyleString; exports.DEFAULT_DATA_VALIDATION_MESSAGE = DEFAULT_DATA_VALIDATION_MESSAGE; exports.DEFAULT_DATA_VALIDATION_TITLE = DEFAULT_DATA_VALIDATION_TITLE; exports.findDataValidation = findDataValidation; exports.getValidationListValues = getValidationListValues; exports.validateCellInput = validateCellInput; exports.findInvalidCells = findInvalidCells; exports.DEFAULT_ROW_HEIGHT = DEFAULT_ROW_HEIGHT; exports.DEFAULT_COLUMN_WIDTH = DEFAULT_COLUMN_WIDTH; exports.getTableSections = getTableSections; exports.getRowSection = getRowSection; exports.rowPassesFilters = rowPassesFilters; exports.computeRowGroups = computeRowGroups; exports.buildSpreadsheetView = buildSpreadsheetView; exports.SpreadsheetController = SpreadsheetController; exports.runSpreadsheetMenuItem = runSpreadsheetMenuItem; exports.clampMenuPosition = clampMenuPosition; exports.getSpreadsheetMenuItems = getSpreadsheetMenuItems; exports.SPREADSHEET_TABLE_ACTIONS = SPREADSHEET_TABLE_ACTIONS; exports.bindSpreadsheetTableActions = bindSpreadsheetTableActions; exports.csvImportAdapter = csvImportAdapter; exports.tsvImportAdapter = tsvImportAdapter; exports.SPREADSHEET_IMPORT_ADAPTERS = SPREADSHEET_IMPORT_ADAPTERS; exports.registerSpreadsheetImportAdapters = registerSpreadsheetImportAdapters; exports.importFileIntoSpreadsheet = importFileIntoSpreadsheet; exports.getSheetTabMenuItems = getSheetTabMenuItems; exports.sheetDropIndex = sheetDropIndex; exports.getNameManagerRows = getNameManagerRows;
-//# sourceMappingURL=chunk-WSQKHXW7.cjs.map
+exports.extractNameDependencies = extractNameDependencies; exports.columnDependencyKey = columnDependencyKey; exports.extractCellDependencies = extractCellDependencies; exports.extractReferenceDependencies = extractReferenceDependencies; exports.rangeDependencyKey = rangeDependencyKey; exports.IntervalIndex = IntervalIndex; exports.DependencyGraph = DependencyGraph; exports.shiftFormulaReferences = shiftFormulaReferences; exports.mapFormulaReferences = mapFormulaReferences; exports.offsetFormulaReferences = offsetFormulaReferences; exports.remapFormulaReferences = remapFormulaReferences; exports.sheetNameNeedsQuotes = sheetNameNeedsQuotes; exports.quoteSheetName = quoteSheetName; exports.formatSheetPrefix = formatSheetPrefix; exports.renameSheetInFormula = renameSheetInFormula; exports.deleteSheetInFormula = deleteSheetInFormula; exports.renameNameInFormula = renameNameInFormula; exports.formulaIdentifiers = formulaIdentifiers; exports.getFormulaCaretContext = getFormulaCaretContext; exports.getFormulaHints = getFormulaHints; exports.applyFormulaSuggestion = applyFormulaSuggestion; exports.NUMBER_FORMAT_PRESETS = NUMBER_FORMAT_PRESETS; exports.numberFormatForCellFormat = numberFormatForCellFormat; exports.cellFormatForNumberFormat = cellFormatForNumberFormat; exports.isGeneralNumberFormat = isGeneralNumberFormat; exports.formatCellForDisplay = formatCellForDisplay; exports.formatCellDisplay = formatCellDisplay; exports.formatValueWithCode = formatValueWithCode; exports.DataSourceBinder = DataSourceBinder; exports.MAX_SHEET_NAME_LENGTH = MAX_SHEET_NAME_LENGTH; exports.MAX_DEFINED_NAME_LENGTH = MAX_DEFINED_NAME_LENGTH; exports.validateSheetName = validateSheetName; exports.nextSheetName = nextSheetName; exports.copySheetName = copySheetName; exports.validateDefinedName = validateDefinedName; exports.isLambdaDefinition = isLambdaDefinition; exports.normalizeRange = normalizeRange; exports.rangeContains = rangeContains; exports.rangesIntersect = rangesIntersect; exports.rangeContainsRange = rangeContainsRange; exports.isSingleCellRange = isSingleCellRange; exports.isBlankValue = isBlankValue; exports.toNumber = toNumber; exports.compareCellValues = compareCellValues; exports.matchesFilterRule = matchesFilterRule; exports.aggregateValues = aggregateValues; exports.roundFloat = roundFloat; exports.fillSeries = fillSeries; exports.computeFillTarget = computeFillTarget; exports.getFillDirection = getFillDirection; exports.SPREADSHEET_CLIPBOARD_MIME = SPREADSHEET_CLIPBOARD_MIME; exports.serializeHtmlTable = serializeHtmlTable; exports.parseHtmlTable = parseHtmlTable; exports.createSpreadsheetClipboardData = createSpreadsheetClipboardData; exports.readSpreadsheetClipboard = readSpreadsheetClipboard; exports.rebaseClipboardRows = rebaseClipboardRows; exports.adjustRangeForStructuralChange = adjustRangeForStructuralChange; exports.adjustRangesForStructuralChange = adjustRangesForStructuralChange; exports.subtractRange = subtractRange; exports.subtractRangeFromRanges = subtractRangeFromRanges; exports.rangesContain = rangesContain; exports.ruleAnchor = ruleAnchor; exports.ruleFormulaAt = ruleFormulaAt; exports.shiftRuleFormula = shiftRuleFormula; exports.forEachRangeCell = forEachRangeCell; exports.formatRuleRanges = formatRuleRanges; exports.parseRuleRanges = parseRuleRanges; exports.CONDITIONAL_FORMAT_ICON_SETS = CONDITIONAL_FORMAT_ICON_SETS; exports.conditionalFormatIconCount = conditionalFormatIconCount; exports.getConditionalFormatIcon = getConditionalFormatIcon; exports.conditionalFormatNumber = conditionalFormatNumber; exports.blendConditionalFormatColors = blendConditionalFormatColors; exports.defaultIconThresholds = defaultIconThresholds; exports.EMPTY_CONDITIONAL_FORMAT_OVERLAY = EMPTY_CONDITIONAL_FORMAT_OVERLAY; exports.ConditionalFormatEngine = ConditionalFormatEngine; exports.matchesTimePeriod = matchesTimePeriod; exports.evaluateConditionalFormats = evaluateConditionalFormats; exports.describeConditionalFormat = describeConditionalFormat; exports.describeDataValidation = describeDataValidation; exports.CONDITIONAL_FORMAT_STYLE_PRESETS = CONDITIONAL_FORMAT_STYLE_PRESETS; exports.DEFAULT_CONDITIONAL_FORMAT_STYLE = DEFAULT_CONDITIONAL_FORMAT_STYLE; exports.CONDITIONAL_FORMAT_PRESETS = CONDITIONAL_FORMAT_PRESETS; exports.CONDITIONAL_FORMAT_TIME_PERIODS = CONDITIONAL_FORMAT_TIME_PERIODS; exports.createConditionalFormatRule = createConditionalFormatRule; exports.DATA_VALIDATION_TYPE_OPTIONS = DATA_VALIDATION_TYPE_OPTIONS; exports.DATA_VALIDATION_OPERATOR_OPTIONS = DATA_VALIDATION_OPERATOR_OPTIONS; exports.DATA_VALIDATION_ERROR_STYLE_OPTIONS = DATA_VALIDATION_ERROR_STYLE_OPTIONS; exports.conditionalFormatContrastColor = conditionalFormatContrastColor; exports.getConditionalFormatCss = getConditionalFormatCss; exports.getDataBarCss = getDataBarCss; exports.conditionalFormatStyleString = conditionalFormatStyleString; exports.DEFAULT_DATA_VALIDATION_MESSAGE = DEFAULT_DATA_VALIDATION_MESSAGE; exports.DEFAULT_DATA_VALIDATION_TITLE = DEFAULT_DATA_VALIDATION_TITLE; exports.findDataValidation = findDataValidation; exports.getValidationListValues = getValidationListValues; exports.validateCellInput = validateCellInput; exports.findInvalidCells = findInvalidCells; exports.DEFAULT_ROW_HEIGHT = DEFAULT_ROW_HEIGHT; exports.DEFAULT_COLUMN_WIDTH = DEFAULT_COLUMN_WIDTH; exports.getTableSections = getTableSections; exports.getRowSection = getRowSection; exports.rowPassesFilters = rowPassesFilters; exports.computeRowGroups = computeRowGroups; exports.buildSpreadsheetView = buildSpreadsheetView; exports.SpreadsheetController = SpreadsheetController; exports.runSpreadsheetMenuItem = runSpreadsheetMenuItem; exports.clampMenuPosition = clampMenuPosition; exports.getSpreadsheetMenuItems = getSpreadsheetMenuItems; exports.SPREADSHEET_TABLE_ACTIONS = SPREADSHEET_TABLE_ACTIONS; exports.bindSpreadsheetTableActions = bindSpreadsheetTableActions; exports.csvImportAdapter = csvImportAdapter; exports.tsvImportAdapter = tsvImportAdapter; exports.SPREADSHEET_IMPORT_ADAPTERS = SPREADSHEET_IMPORT_ADAPTERS; exports.registerSpreadsheetImportAdapters = registerSpreadsheetImportAdapters; exports.importFileIntoSpreadsheet = importFileIntoSpreadsheet; exports.getSheetTabMenuItems = getSheetTabMenuItems; exports.sheetDropIndex = sheetDropIndex; exports.getNameManagerRows = getNameManagerRows; exports.SPREADSHEET_COLUMN_HEADER_HEIGHT = SPREADSHEET_COLUMN_HEADER_HEIGHT; exports.SPREADSHEET_ROW_HEADER_WIDTH = SPREADSHEET_ROW_HEADER_WIDTH; exports.SPREADSHEET_GROUP_ROW_HEIGHT = SPREADSHEET_GROUP_ROW_HEIGHT; exports.SPREADSHEET_VIRTUAL_ROW_THRESHOLD = SPREADSHEET_VIRTUAL_ROW_THRESHOLD; exports.SPREADSHEET_VIRTUAL_COLUMN_THRESHOLD = SPREADSHEET_VIRTUAL_COLUMN_THRESHOLD; exports.SPREADSHEET_DEFAULT_VIEWPORT = SPREADSHEET_DEFAULT_VIEWPORT; exports.measureSpreadsheetView = measureSpreadsheetView; exports.shouldVirtualizeSpreadsheet = shouldVirtualizeSpreadsheet; exports.fullSpreadsheetViewWindow = fullSpreadsheetViewWindow; exports.getSpreadsheetViewWindow = getSpreadsheetViewWindow; exports.getSpreadsheetScrollToCell = getSpreadsheetScrollToCell; exports.sameSpreadsheetViewWindow = sameSpreadsheetViewWindow;
+//# sourceMappingURL=chunk-NQF32I6Z.cjs.map