@devmm/puredocs-excel-formula 1.0.4 → 1.0.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TVE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -4457,12 +4457,15 @@ function parseFormula(formula) {
   const stripped = formula.startsWith("=") ? formula.slice(1) : formula;
   const cached = astCache.get(stripped);
   if (cached !== void 0) return cached;
-  const lexer = new FormulaLexer(stripped);
-  const tokens = lexer.tokenize();
-  const ast = new FormulaParser(tokens).parse();
+  const ast = parseFormulaUncached(stripped);
   astCache.set(stripped, ast);
   return ast;
 }
+function parseFormulaUncached(formula) {
+  const stripped = formula.startsWith("=") ? formula.slice(1) : formula;
+  const tokens = new FormulaLexer(stripped).tokenize();
+  return new FormulaParser(tokens).parse();
+}
 var DEFAULT_LAMBDA_DEPTH = 1024;
 function buildContext(sheet, opts) {
   const evaluating = opts.evaluating ?? /* @__PURE__ */ new Set();
@@ -4486,7 +4489,7 @@ function buildContext(sheet, opts) {
   return ctx;
 }
 function resolveName(name, sheet, workbook, evaluating, resolving, resolved, recursionGuard) {
-  const key = `${sheet.name}\0${name.toUpperCase()}`;
+  const key = `${sheet.name} ${name.toUpperCase()}`;
   const cached = resolved.get(key);
   if (cached !== void 0) return cached;
   if (resolving.has(key)) return FormulaValue.errorRef;
@@ -4514,7 +4517,13 @@ function resolveName(name, sheet, workbook, evaluating, resolving, resolved, rec
 function evaluateFormula(formula, sheet, options) {
   if (!formula) return FormulaValue.blank;
   try {
-    const ast = parseFormula(formula);
+    return evaluateAst(parseFormula(formula), sheet, options);
+  } catch {
+    return FormulaValue.errorValue;
+  }
+}
+function evaluateAst(ast, sheet, options) {
+  try {
     const ctx = buildContext(sheet, {
       workbook: options?.workbook,
       formulaRow: options?.formulaRow,
@@ -4602,6 +4611,95 @@ function refContains(ref, sheet, row2, col) {
   return ref.sheet === sheet && row2 >= ref.startRow && row2 <= ref.endRow && col >= ref.startCol && col <= ref.endCol;
 }
 
+// src/dependency-index.ts
+var TILE_ROWS = 64;
+var TILE_COLS = 64;
+var MAX_TILES_PER_REF = 32;
+var _tiles, _wide, _placements, _DependencyIndex_instances, fileIn_fn;
+var DependencyIndex = class {
+  constructor() {
+    __privateAdd(this, _DependencyIndex_instances);
+    /** `sheet|tileRow|tileCol` → formula keys whose precedents overlap that tile. */
+    __privateAdd(this, _tiles, /* @__PURE__ */ new Map());
+    /** sheet → formula keys with a precedent too broad to tile. */
+    __privateAdd(this, _wide, /* @__PURE__ */ new Map());
+    /** formula key → the bucket keys it was filed under, for cheap removal. */
+    __privateAdd(this, _placements, /* @__PURE__ */ new Map());
+  }
+  /** Registers (or re-registers) a formula's precedent rectangles. */
+  add(formulaKey, refs) {
+    this.remove(formulaKey);
+    if (refs.length === 0) return;
+    const buckets = [];
+    for (const ref of refs) {
+      const tileRow0 = ref.startRow / TILE_ROWS | 0;
+      const tileRow1 = ref.endRow / TILE_ROWS | 0;
+      const tileCol0 = ref.startCol / TILE_COLS | 0;
+      const tileCol1 = ref.endCol / TILE_COLS | 0;
+      const tileCount = (tileRow1 - tileRow0 + 1) * (tileCol1 - tileCol0 + 1);
+      if (tileCount > MAX_TILES_PER_REF) {
+        __privateMethod(this, _DependencyIndex_instances, fileIn_fn).call(this, __privateGet(this, _wide), ref.sheet, formulaKey, buckets, `w ${ref.sheet}`);
+        continue;
+      }
+      for (let tr = tileRow0; tr <= tileRow1; tr++) {
+        for (let tc = tileCol0; tc <= tileCol1; tc++) {
+          const key = `${ref.sheet} ${tr} ${tc}`;
+          __privateMethod(this, _DependencyIndex_instances, fileIn_fn).call(this, __privateGet(this, _tiles), key, formulaKey, buckets, `t ${key}`);
+        }
+      }
+    }
+    __privateGet(this, _placements).set(formulaKey, buckets);
+  }
+  /** Forgets a formula. */
+  remove(formulaKey) {
+    const buckets = __privateGet(this, _placements).get(formulaKey);
+    if (!buckets) return;
+    for (const bucket of buckets) {
+      const wide = bucket.charCodeAt(0) === 119;
+      const store = wide ? __privateGet(this, _wide) : __privateGet(this, _tiles);
+      const key = bucket.slice(2);
+      const set = store.get(key);
+      if (!set) continue;
+      set.delete(formulaKey);
+      if (set.size === 0) store.delete(key);
+    }
+    __privateGet(this, _placements).delete(formulaKey);
+  }
+  /** Drops every registration. */
+  clear() {
+    __privateGet(this, _tiles).clear();
+    __privateGet(this, _wide).clear();
+    __privateGet(this, _placements).clear();
+  }
+  /**
+   * Calls `visit` with the key of each formula that *may* read the given cell.
+   * Callers still confirm with {@link refContains}: a tile is coarser than a
+   * rectangle, so this over-approximates by at most a tile's worth.
+   */
+  candidates(sheet, row2, col, visit) {
+    const tile = __privateGet(this, _tiles).get(
+      `${sheet} ${row2 / TILE_ROWS | 0} ${col / TILE_COLS | 0}`
+    );
+    if (tile) for (const key of tile) visit(key);
+    const wide = __privateGet(this, _wide).get(sheet);
+    if (wide) for (const key of wide) visit(key);
+  }
+};
+_tiles = new WeakMap();
+_wide = new WeakMap();
+_placements = new WeakMap();
+_DependencyIndex_instances = new WeakSet();
+fileIn_fn = function(store, key, formulaKey, buckets, bucketId) {
+  let set = store.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    store.set(key, set);
+  }
+  if (set.has(formulaKey)) return;
+  set.add(formulaKey);
+  buckets.push(bucketId);
+};
+
 // src/recalc-engine.ts
 function createWorkbookRecalcModel(workbook) {
   return {
@@ -4634,7 +4732,7 @@ function parseKey(key) {
   const { row: row2, column: column2 } = puredocsExcel.parseCellRef(ref);
   return { sheet, ref, row: row2, col: column2 };
 }
-var _model, _registry, _formulas, _sheetNames, _spills, _spillOwner, _RecalcEngine_instances, rememberSheet_fn, recalcFrom_fn, dependentClosure_fn, directDependents_fn, evaluatePass_fn, writeResult_fn, isOccupied_fn, clearSpill_fn, evaluateFormulaValue_fn, sheetLike_fn, buildWorkbookLike_fn;
+var _model, _registry, _formulas, _sheetNames, _spills, _spillOwner, _dependents, _volatiles, _sheetLikes, _workbookLike, _RecalcEngine_instances, register_fn, unregister_fn, rememberSheet_fn, applyShift_fn, shiftPrecedents_fn, shiftSpillBookkeeping_fn, recalcFrom_fn, runFixpoint_fn, addVolatiles_fn, dependentClosure_fn, forEachDirectDependent_fn, evaluatePass_fn, writeResult_fn, isOccupied_fn, clearSpill_fn, evaluateFormulaValue_fn, sheetLike_fn, buildSheetLike_fn, buildWorkbookLike_fn;
 var RecalcEngine = class {
   constructor(model, registry = FunctionRegistry.default) {
     __privateAdd(this, _RecalcEngine_instances);
@@ -4647,6 +4745,19 @@ var RecalcEngine = class {
     __privateAdd(this, _spills, /* @__PURE__ */ new Map());
     /** spilled cellKey → the anchor cellKey that owns it. */
     __privateAdd(this, _spillOwner, /* @__PURE__ */ new Map());
+    /**
+     * Reverse dependency index, so finding the formulas that read a cell does not
+     * mean testing every registered formula.
+     */
+    __privateAdd(this, _dependents, new DependencyIndex());
+    /**
+     * Keys of the volatile formulas. Maintained incrementally: scanning every
+     * formula for volatility on each edit is O(F) per keystroke on its own.
+     */
+    __privateAdd(this, _volatiles, /* @__PURE__ */ new Set());
+    /** Memoised per-sheet adapters — these are stateless w.r.t. the formula. */
+    __privateAdd(this, _sheetLikes, /* @__PURE__ */ new Map());
+    __privateAdd(this, _workbookLike);
     __privateSet(this, _model, model);
     __privateSet(this, _registry, registry);
   }
@@ -4662,7 +4773,7 @@ var RecalcEngine = class {
     const s = normSheet(sheet);
     const r = normRef(ref);
     const { row: row2, column: column2 } = puredocsExcel.parseCellRef(r);
-    const ast = parseFormula(text);
+    const ast = parseFormulaUncached(text);
     const { refs, volatile } = extractReferences(
       ast,
       s,
@@ -4670,18 +4781,21 @@ var RecalcEngine = class {
       __privateGet(this, _model).getDefinedName ? (n, sh) => __privateGet(this, _model).getDefinedName(n, sh) : void 0
     );
     __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
-    __privateGet(this, _formulas).set(keyOf(s, r), {
+    const key = keyOf(s, r);
+    __privateMethod(this, _RecalcEngine_instances, register_fn).call(this, {
       sheet: s,
       sheetName: sheet,
       ref: r,
+      key,
       row: row2,
       col: column2,
       formula: text,
+      ast,
       refs,
       volatile
     });
     __privateGet(this, _model).setCellFormula?.(sheet, r, text);
-    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }], keyOf(s, r));
+    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }], key);
   }
   /**
    * Removes a formula from a cell and recalculates its dependents (which may now
@@ -4690,8 +4804,9 @@ var RecalcEngine = class {
   clearCellFormula(sheet, ref) {
     const s = normSheet(sheet);
     const r = normRef(ref);
-    const existed = __privateGet(this, _formulas).delete(keyOf(s, r));
-    if (!existed) return [];
+    const key = keyOf(s, r);
+    if (!__privateGet(this, _formulas).has(key)) return [];
+    __privateMethod(this, _RecalcEngine_instances, unregister_fn).call(this, key);
     __privateGet(this, _model).clearCell?.(sheet, r);
     const { row: row2, column: column2 } = puredocsExcel.parseCellRef(r);
     return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }]);
@@ -4727,6 +4842,39 @@ var RecalcEngine = class {
   getPrecedents(sheet, ref) {
     return __privateGet(this, _formulas).get(keyOf(sheet, ref))?.refs ?? [];
   }
+  // ── Structural edits ─────────────────────────────────────────────────────────
+  /**
+   * Tells the engine rows were inserted on a sheet. Call AFTER the
+   * corresponding `Worksheet.insertRows` (the model must already reflect the
+   * edit). The dependency graph is translated in place — registrations,
+   * formula text and spill bookkeeping all move — and only volatile formulas
+   * are recomputed, because a pure translation changes no values.
+   *
+   * @example
+   * ws.insertRows(3, 2);
+   * engine.onRowsInserted('S1', 3, 2);
+   */
+  onRowsInserted(sheet, at, count2 = 1) {
+    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "row", kind: "insert", at, count: count2, sheetName: sheet });
+  }
+  /**
+   * Tells the engine rows were deleted on a sheet. Call AFTER the
+   * corresponding `Worksheet.deleteRows`. Registrations inside the deleted
+   * band are dropped; the rest of the graph is translated, and only formulas
+   * whose precedents touched the deleted band (plus their dependents and
+   * volatiles) are recomputed.
+   */
+  onRowsDeleted(sheet, at, count2 = 1) {
+    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "row", kind: "delete", at, count: count2, sheetName: sheet });
+  }
+  /** Column counterpart to {@link onRowsInserted}. */
+  onColumnsInserted(sheet, at, count2 = 1) {
+    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "col", kind: "insert", at, count: count2, sheetName: sheet });
+  }
+  /** Column counterpart to {@link onRowsDeleted}. */
+  onColumnsDeleted(sheet, at, count2 = 1) {
+    return __privateMethod(this, _RecalcEngine_instances, applyShift_fn).call(this, { dim: "col", kind: "delete", at, count: count2, sheetName: sheet });
+  }
 };
 _model = new WeakMap();
 _registry = new WeakMap();
@@ -4734,10 +4882,152 @@ _formulas = new WeakMap();
 _sheetNames = new WeakMap();
 _spills = new WeakMap();
 _spillOwner = new WeakMap();
+_dependents = new WeakMap();
+_volatiles = new WeakMap();
+_sheetLikes = new WeakMap();
+_workbookLike = new WeakMap();
 _RecalcEngine_instances = new WeakSet();
+/** Registers an entry in the map, the reverse index and the volatile set. */
+register_fn = function(entry) {
+  __privateGet(this, _formulas).set(entry.key, entry);
+  __privateGet(this, _dependents).add(entry.key, entry.refs);
+  if (entry.volatile) __privateGet(this, _volatiles).add(entry.key);
+  else __privateGet(this, _volatiles).delete(entry.key);
+};
+unregister_fn = function(key) {
+  __privateGet(this, _formulas).delete(key);
+  __privateGet(this, _dependents).remove(key);
+  __privateGet(this, _volatiles).delete(key);
+};
 rememberSheet_fn = function(name) {
   __privateGet(this, _sheetNames).set(normSheet(name), name);
 };
+applyShift_fn = function(shift) {
+  const editedSheet = normSheet(shift.sheetName);
+  const isRowShift = shift.dim === "row";
+  const bandEnd = shift.at + shift.count - 1;
+  const rekeyed = [];
+  const needsRecalc = /* @__PURE__ */ new Set();
+  for (const e of __privateGet(this, _formulas).values()) {
+    let row2 = e.row;
+    let col = e.col;
+    if (e.sheet === editedSheet) {
+      const shifted = puredocsExcel.shiftIndex(isRowShift ? row2 : col, shift);
+      if (shifted === null) continue;
+      if (isRowShift) row2 = shifted;
+      else col = shifted;
+    }
+    const touchedBand = shift.kind === "delete" && e.refs.some((r) => r.sheet === editedSheet && (isRowShift ? r.endRow >= shift.at && r.startRow <= bandEnd : r.endCol >= shift.at && r.startCol <= bandEnd));
+    const rewritten = puredocsExcel.shiftFormulaRefs(e.formula, shift, e.sheetName);
+    const moved = row2 !== e.row || col !== e.col;
+    const ref = moved ? puredocsExcel.cellRefFromRowCol(row2, col) : e.ref;
+    const key = moved ? keyOf(e.sheet, ref) : e.key;
+    rekeyed.push({
+      ...e,
+      ref,
+      key,
+      row: row2,
+      col,
+      formula: rewritten.changed ? rewritten.text : e.formula,
+      // A rewritten formula's cached AST no longer matches its text; it is
+      // re-parsed lazily, and only if the cell is actually evaluated again.
+      ast: rewritten.changed ? void 0 : e.ast,
+      refs: __privateMethod(this, _RecalcEngine_instances, shiftPrecedents_fn).call(this, e.refs, shift, editedSheet)
+      // Volatility is a property of which *functions* a formula calls, and
+      // rewriting references cannot change that.
+    });
+    if (touchedBand || rewritten.hasRefError) needsRecalc.add(key);
+  }
+  __privateSet(this, _formulas, /* @__PURE__ */ new Map());
+  __privateGet(this, _dependents).clear();
+  __privateGet(this, _volatiles).clear();
+  for (const e of rekeyed) __privateMethod(this, _RecalcEngine_instances, register_fn).call(this, e);
+  __privateMethod(this, _RecalcEngine_instances, shiftSpillBookkeeping_fn).call(this, shift, editedSheet);
+  const pending = /* @__PURE__ */ new Map();
+  for (const k of needsRecalc) {
+    const e = __privateGet(this, _formulas).get(k);
+    if (e) pending.set(k, e);
+  }
+  for (const e of __privateGet(this, _formulas).values()) {
+    if (e.volatile) pending.set(e.key, e);
+  }
+  return __privateMethod(this, _RecalcEngine_instances, runFixpoint_fn).call(this, pending, /* @__PURE__ */ new Set());
+};
+/**
+ * Translates precedent rectangles across a structural edit.
+ *
+ * This is arithmetic rather than a re-parse of the rewritten formula, and the
+ * two are equivalent by construction: `shiftFormulaRefs` derives the new
+ * reference text by calling `shiftSpan`/`shiftIndex` on exactly these numbers,
+ * so applying the same functions to the stored rectangle yields the same
+ * region. A rectangle that is entirely deleted disappears, matching the
+ * `#REF!` the text rewrite produces.
+ */
+shiftPrecedents_fn = function(refs, shift, editedSheet) {
+  const out = [];
+  for (const r of refs) {
+    if (r.sheet !== editedSheet) {
+      out.push(r);
+      continue;
+    }
+    if (shift.dim === "row") {
+      const span = puredocsExcel.shiftSpan(r.startRow, r.endRow, shift);
+      if (!span) continue;
+      out.push({
+        sheet: r.sheet,
+        startRow: span.start,
+        endRow: Math.min(span.end, puredocsExcel.EXCEL_MAX_ROWS),
+        startCol: r.startCol,
+        endCol: r.endCol
+      });
+    } else {
+      const span = puredocsExcel.shiftSpan(r.startCol, r.endCol, shift);
+      if (!span) continue;
+      out.push({
+        sheet: r.sheet,
+        startRow: r.startRow,
+        endRow: r.endRow,
+        startCol: span.start,
+        endCol: Math.min(span.end, puredocsExcel.EXCEL_MAX_COLUMNS)
+      });
+    }
+  }
+  return out;
+};
+/** Translates spill ownership across a structural edit on `editedSheet`. */
+shiftSpillBookkeeping_fn = function(shift, editedSheet) {
+  const shiftCellKey = (key) => {
+    const { sheet, row: row2, col } = parseKey(key);
+    if (sheet !== editedSheet) return key;
+    const r = shift.dim === "row" ? puredocsExcel.shiftIndex(row2, shift) : row2;
+    const c = shift.dim === "col" ? puredocsExcel.shiftIndex(col, shift) : col;
+    if (r === null || c === null) return null;
+    return keyOf(sheet, puredocsExcel.cellRefFromRowCol(r, c));
+  };
+  const newSpills = /* @__PURE__ */ new Map();
+  __privateGet(this, _spillOwner).clear();
+  for (const [anchor, members] of __privateGet(this, _spills)) {
+    const newAnchor = shiftCellKey(anchor);
+    if (newAnchor === null) {
+      for (const m of members) {
+        const shifted = shiftCellKey(m);
+        if (!shifted) continue;
+        const cell = parseKey(shifted);
+        __privateGet(this, _model).setCellValue(__privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null);
+      }
+      continue;
+    }
+    const newMembers = /* @__PURE__ */ new Set();
+    for (const m of members) {
+      const shifted = shiftCellKey(m);
+      if (!shifted) continue;
+      newMembers.add(shifted);
+      __privateGet(this, _spillOwner).set(shifted, newAnchor);
+    }
+    newSpills.set(newAnchor, newMembers);
+  }
+  __privateSet(this, _spills, newSpills);
+};
 // ── Internals ────────────────────────────────────────────────────────────────
 /**
  * Recomputes formulas affected by the given changed cells, to a fixpoint.
@@ -4753,13 +5043,17 @@ recalcFrom_fn = function(seeds, includeKey) {
   const results = [];
   const evaluated = /* @__PURE__ */ new Set();
   let pending = __privateMethod(this, _RecalcEngine_instances, dependentClosure_fn).call(this, seeds, evaluated);
-  for (const e of __privateGet(this, _formulas).values()) {
-    if (e.volatile) pending.set(keyOf(e.sheet, e.ref), e);
-  }
+  __privateMethod(this, _RecalcEngine_instances, addVolatiles_fn).call(this, pending);
   if (includeKey) {
     const self = __privateGet(this, _formulas).get(includeKey);
     if (self) pending.set(includeKey, self);
   }
+  results.push(...__privateMethod(this, _RecalcEngine_instances, runFixpoint_fn).call(this, pending, evaluated));
+  return results;
+};
+/** Evaluates `pending` entries to a fixpoint, following spill-induced changes. */
+runFixpoint_fn = function(pending, evaluated) {
+  const results = [];
   let guard = 0;
   const maxIterations = __privateGet(this, _formulas).size + 8;
   while (pending.size > 0 && guard++ <= maxIterations) {
@@ -4770,28 +5064,47 @@ recalcFrom_fn = function(seeds, includeKey) {
   }
   return results;
 };
-/** Formula entries (not yet evaluated) whose precedents include one of the cells. */
+/** Adds every volatile formula to a pending set. */
+addVolatiles_fn = function(pending) {
+  for (const key of __privateGet(this, _volatiles)) {
+    const e = __privateGet(this, _formulas).get(key);
+    if (e) pending.set(key, e);
+  }
+};
+/**
+ * Formula entries (not yet evaluated) whose precedents include one of the
+ * cells, transitively. The queue is walked with a head index — Array.shift()
+ * is O(n) per dequeue, which turns a long dependency chain quadratic.
+ */
 dependentClosure_fn = function(cells, evaluated) {
   const out = /* @__PURE__ */ new Map();
   const queue = [...cells];
-  while (queue.length > 0) {
-    const cell = queue.shift();
-    for (const dep of __privateMethod(this, _RecalcEngine_instances, directDependents_fn).call(this, cell)) {
-      const k = keyOf(dep.sheet, dep.ref);
-      if (out.has(k) || evaluated.has(k)) continue;
-      out.set(k, dep);
+  for (let head = 0; head < queue.length; head++) {
+    const cell = queue[head];
+    __privateMethod(this, _RecalcEngine_instances, forEachDirectDependent_fn).call(this, cell, (dep) => {
+      if (out.has(dep.key) || evaluated.has(dep.key)) return;
+      out.set(dep.key, dep);
       queue.push({ sheet: dep.sheet, row: dep.row, col: dep.col });
-    }
+    });
   }
   return out;
 };
-/** Formula entries whose precedents include the given cell. */
-directDependents_fn = function(cell) {
-  const out = [];
-  for (const e of __privateGet(this, _formulas).values()) {
-    if (e.refs.some((ref) => refContains(ref, cell.sheet, cell.row, cell.col))) out.push(e);
-  }
-  return out;
+/**
+ * Visits the formula entries whose precedents include the given cell, via the
+ * reverse index. The index over-approximates (it buckets rectangles into
+ * tiles), so each candidate is still confirmed against its real rectangles.
+ */
+forEachDirectDependent_fn = function(cell, visit) {
+  __privateGet(this, _dependents).candidates(cell.sheet, cell.row, cell.col, (key) => {
+    const e = __privateGet(this, _formulas).get(key);
+    if (!e) return;
+    for (const ref of e.refs) {
+      if (refContains(ref, cell.sheet, cell.row, cell.col)) {
+        visit(e);
+        return;
+      }
+    }
+  });
 };
 /**
  * Topologically sorts the given entries and evaluates them, writing results
@@ -4800,32 +5113,32 @@ directDependents_fn = function(cell) {
  */
 evaluatePass_fn = function(entries) {
   const inSet = /* @__PURE__ */ new Map();
-  for (const e of entries) inSet.set(keyOf(e.sheet, e.ref), e);
+  for (const e of entries) inSet.set(e.key, e);
   const indegree = /* @__PURE__ */ new Map();
   const dependents = /* @__PURE__ */ new Map();
   for (const k of inSet.keys()) {
     indegree.set(k, 0);
     dependents.set(k, []);
   }
-  for (const e of entries) {
-    const depKey = keyOf(e.sheet, e.ref);
-    for (const [pk, pe] of inSet) {
-      if (pk === depKey) continue;
-      if (e.refs.some((ref) => refContains(ref, pe.sheet, pe.row, pe.col))) {
-        dependents.get(pk).push(depKey);
-        indegree.set(depKey, indegree.get(depKey) + 1);
-      }
-    }
+  for (const pe of entries) {
+    const seen = /* @__PURE__ */ new Set();
+    __privateMethod(this, _RecalcEngine_instances, forEachDirectDependent_fn).call(this, { sheet: pe.sheet, row: pe.row, col: pe.col }, (dep) => {
+      if (dep.key === pe.key || !inSet.has(dep.key) || seen.has(dep.key)) return;
+      seen.add(dep.key);
+      dependents.get(pe.key).push(dep.key);
+      indegree.set(dep.key, indegree.get(dep.key) + 1);
+    });
   }
   const ready = [];
   for (const [k, d] of indegree) if (d === 0) ready.push(k);
   const order = [];
-  while (ready.length > 0) {
-    const k = ready.shift();
+  for (let head = 0; head < ready.length; head++) {
+    const k = ready[head];
     order.push(k);
     for (const d of dependents.get(k)) {
-      indegree.set(d, indegree.get(d) - 1);
-      if (indegree.get(d) === 0) ready.push(d);
+      const left2 = indegree.get(d) - 1;
+      indegree.set(d, left2);
+      if (left2 === 0) ready.push(d);
     }
   }
   const results = [];
@@ -4839,7 +5152,7 @@ evaluatePass_fn = function(entries) {
   }
   for (const [k, e] of inSet) {
     if (emitted.has(k)) continue;
-    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, keyOf(e.sheet, e.ref), changed);
+    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, e.key, changed);
     const value2 = FormulaValue.errorRef.toObject();
     __privateGet(this, _model).setCellValue(e.sheetName, e.ref, value2);
     changed.push({ sheet: e.sheet, row: e.row, col: e.col });
@@ -4854,7 +5167,7 @@ evaluatePass_fn = function(entries) {
  * an array shrinks, previously-spilled cells it no longer covers are cleared.
  */
 writeResult_fn = function(e) {
-  const anchorKey = keyOf(e.sheet, e.ref);
+  const anchorKey = e.key;
   const fv2 = __privateMethod(this, _RecalcEngine_instances, evaluateFormulaValue_fn).call(this, e);
   const changed = [];
   const prevSpill = __privateGet(this, _spills).get(anchorKey) ?? /* @__PURE__ */ new Set();
@@ -4938,15 +5251,33 @@ clearSpill_fn = function(anchorKey, changed) {
   __privateGet(this, _spills).delete(anchorKey);
 };
 evaluateFormulaValue_fn = function(e) {
-  const wb = __privateMethod(this, _RecalcEngine_instances, buildWorkbookLike_fn).call(this);
-  const ws = __privateMethod(this, _RecalcEngine_instances, sheetLike_fn).call(this, e.sheetName);
-  return evaluateFormula(e.formula, ws, {
-    workbook: wb,
+  if (!e.ast) {
+    try {
+      e.ast = parseFormulaUncached(e.formula);
+    } catch {
+      return FormulaValue.errorValue;
+    }
+  }
+  return evaluateAst(e.ast, __privateMethod(this, _RecalcEngine_instances, sheetLike_fn).call(this, e.sheetName), {
+    workbook: __privateMethod(this, _RecalcEngine_instances, buildWorkbookLike_fn).call(this),
     formulaRow: e.row,
     formulaCol: e.col
   });
 };
+/**
+ * Per-sheet evaluator adapter. Memoised: these hold no per-formula state, and
+ * rebuilding one (with its four closures) for every formula evaluated made a
+ * full recalc allocate several objects per cell.
+ */
 sheetLike_fn = function(sheetName) {
+  let cached = __privateGet(this, _sheetLikes).get(sheetName);
+  if (!cached) {
+    cached = __privateMethod(this, _RecalcEngine_instances, buildSheetLike_fn).call(this, sheetName);
+    __privateGet(this, _sheetLikes).set(sheetName, cached);
+  }
+  return cached;
+};
+buildSheetLike_fn = function(sheetName) {
   return {
     name: sheetName,
     getCellValue: (ref) => __privateGet(this, _model).getCellValue(sheetName, ref),
@@ -4956,8 +5287,9 @@ sheetLike_fn = function(sheetName) {
   };
 };
 buildWorkbookLike_fn = function() {
+  if (__privateGet(this, _workbookLike)) return __privateGet(this, _workbookLike);
   const self = this;
-  return {
+  return __privateSet(this, _workbookLike, {
     get worksheets() {
       return [...__privateGet(self, _sheetNames).values()].map((n) => {
         var _a;
@@ -4969,7 +5301,7 @@ buildWorkbookLike_fn = function() {
       return __privateMethod(_a = self, _RecalcEngine_instances, sheetLike_fn).call(_a, name);
     },
     getDefinedName: __privateGet(this, _model).getDefinedName ? (name, sheet) => __privateGet(this, _model).getDefinedName(name, sheet) : void 0
-  };
+  });
 };
 
 exports.ArrayValue = ArrayValue;
@@ -5004,10 +5336,12 @@ exports.UnaryOpNode = UnaryOpNode;
 exports.UnaryOperator = UnaryOperator;
 exports.clearAstCache = clearAstCache;
 exports.createWorkbookRecalcModel = createWorkbookRecalcModel;
+exports.evaluateAst = evaluateAst;
 exports.evaluateFormula = evaluateFormula;
 exports.extractReferences = extractReferences;
 exports.getAstCacheStats = getAstCacheStats;
 exports.parseFormula = parseFormula;
+exports.parseFormulaUncached = parseFormulaUncached;
 exports.refContains = refContains;
 exports.registerAggregate = registerAggregate;
 exports.registerArray = registerArray;