ooxml-core 1.2.0 → 1.2.1

package/dist/xlsx/ui/index.mjs

@@ -2040,7 +2040,7 @@ var NAME_RE = /^[A-Za-z_\\\u00A1-\uFFFF][A-Za-z0-9_.?\\\u00A1-\uFFFF]*/;
 var CELL_RE = /^(\$?)([A-Za-z]{1,3})(\$?)(\d{1,7})/;
 var COLS_RE = /^(\$?)([A-Za-z]{1,3}):(\$?)([A-Za-z]{1,3})/;
 var ROWS_RE = /^(\$?)(\d{1,7}):(\$?)(\d{1,7})/;
-var NUMBER_RE2 = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/;
+var NUMBER_RE2 = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/;
 var sticky = (re) => new RegExp(re.source.replace(/^\^/, ""), "y");
 var CELL_AT = sticky(CELL_RE);
 var COLS_AT = sticky(COLS_RE);
@@ -2412,7 +2412,9 @@ var PREC_INTERSECT = 9;
 var PREC_RANGE = 10;
 var OPERAND_START = /* @__PURE__ */ new Set(["ref", "name", "func", "open", "structured"]);
 function parseFormula(formula) {
-  const all2 = tokenize(formula);
+  return parseTokens(tokenize(formula));
+}
+function parseTokens(all2) {
   const tokens = [];
   const wsBefore = [];
   let sawWs = false;
@@ -2697,6 +2699,222 @@ function localDateToSerial(date, date1904 = date1904Mode) {
   return base + (utc - dayStart) / DAY_MS;
 }
 
+// xlsx/formula/area-index.ts
+var BUCKET_WIDTH = 64;
+var CHUNK_SHIFT = 6;
+var CHUNKS = 64;
+function push(map, key, value2) {
+  const list = map.get(key);
+  if (list) list.push(value2);
+  else map.set(key, [value2]);
+}
+function inner(map, sheet) {
+  let found = map.get(sheet);
+  if (!found) map.set(sheet, found = /* @__PURE__ */ new Map());
+  return found;
+}
+var AreaIndex = class {
+  cells = /* @__PURE__ */ new Map();
+  chunked = /* @__PURE__ */ new Map();
+  tall = /* @__PURE__ */ new Map();
+  wide = /* @__PURE__ */ new Map();
+  add(area, node) {
+    const { start, end } = area.range;
+    if (start.row === end.row && end.col - start.col + 1 <= BUCKET_WIDTH) {
+      const cells = inner(this.cells, area.sheet);
+      for (let col = start.col; col <= end.col; col++) push(cells, cellKey(start.row, col), node);
+      return;
+    }
+    const entry = { range: area.range, node };
+    if (end.col - start.col + 1 > BUCKET_WIDTH) {
+      const list = this.wide.get(area.sheet);
+      if (list) list.push(entry);
+      else this.wide.set(area.sheet, [entry]);
+      return;
+    }
+    const first2 = start.row >> CHUNK_SHIFT;
+    const last = end.row >> CHUNK_SHIFT;
+    if (last - first2 + 1 > CHUNKS) {
+      const cols2 = inner(this.tall, area.sheet);
+      for (let c = start.col; c <= end.col; c++) push(cols2, c, entry);
+      return;
+    }
+    const cols = inner(this.chunked, area.sheet);
+    for (let c = start.col; c <= end.col; c++) {
+      let chunks = cols.get(c);
+      if (!chunks) cols.set(c, chunks = /* @__PURE__ */ new Map());
+      for (let k = first2; k <= last; k++) push(chunks, k, entry);
+    }
+  }
+  /** Items whose areas intersect `range` on `sheet` (each once). */
+  dependents(sheet, range2, out) {
+    const found = out instanceof Set ? out : /* @__PURE__ */ new Set();
+    this.collect(sheet, range2, found);
+    if (Array.isArray(out)) for (const node of found) out.push(node);
+  }
+  collect(sheet, range2, out) {
+    const { start, end } = range2;
+    const check3 = (list) => {
+      if (list) {
+        for (const entry of list) if (rangesIntersect(entry.range, range2)) out.add(entry.node);
+      }
+    };
+    const cells = this.cells.get(sheet);
+    if (cells) {
+      const size = (end.row - start.row + 1) * (end.col - start.col + 1);
+      if (size <= 4096) {
+        for (let r = start.row; r <= end.row; r++) {
+          for (let c = start.col; c <= end.col; c++) {
+            const list = cells.get(cellKey(r, c));
+            if (list) for (const node of list) out.add(node);
+          }
+        }
+      } else {
+        for (const [key, list] of cells) {
+          const { row: row2, col } = keyToAddress(key);
+          if (row2 >= start.row && row2 <= end.row && col >= start.col && col <= end.col)
+            for (const node of list) out.add(node);
+        }
+      }
+    }
+    const columns = (map, visit2) => {
+      if (!map) return;
+      if (end.col - start.col + 1 <= map.size) {
+        for (let c = start.col; c <= end.col; c++) if (map.has(c)) visit2(c);
+      } else for (const c of map.keys()) if (c >= start.col && c <= end.col) visit2(c);
+    };
+    const chunked = this.chunked.get(sheet);
+    const first2 = start.row >> CHUNK_SHIFT;
+    const last = end.row >> CHUNK_SHIFT;
+    columns(chunked, (c) => {
+      const chunks = chunked?.get(c);
+      if (last - first2 + 1 <= chunks.size) {
+        for (let k = first2; k <= last; k++) check3(chunks.get(k));
+      } else for (const [k, list] of chunks) if (k >= first2 && k <= last) check3(list);
+    });
+    const tall = this.tall.get(sheet);
+    columns(tall, (c) => check3(tall?.get(c)));
+    check3(this.wide.get(sheet));
+  }
+};
+
+// xlsx/formula/graph-index.ts
+var ColumnIndex = class {
+  sheets = /* @__PURE__ */ new Map();
+  constructor(nodes) {
+    for (const node of nodes) {
+      let cols = this.sheets.get(node.sheet);
+      if (!cols) this.sheets.set(node.sheet, cols = /* @__PURE__ */ new Map());
+      let list = cols.get(node.col);
+      if (!list) cols.set(node.col, list = []);
+      list.push(node);
+    }
+    for (const cols of this.sheets.values())
+      for (const list of cols.values()) list.sort((a, b) => a.row - b.row);
+  }
+  nodesIn(area, out) {
+    const cols = this.sheets.get(area.sheet);
+    if (!cols) return;
+    const { start, end } = area.range;
+    const width = end.col - start.col + 1;
+    const scan2 = (list) => {
+      let lo = 0;
+      let hi = list.length;
+      while (lo < hi) {
+        const mid = lo + hi >> 1;
+        if (list[mid].row < start.row) lo = mid + 1;
+        else hi = mid;
+      }
+      for (let i2 = lo; i2 < list.length; i2++) {
+        const node = list[i2];
+        if (node.row > end.row) break;
+        out.push(node);
+      }
+    };
+    if (width <= cols.size) {
+      for (let c = start.col; c <= end.col; c++) {
+        const list = cols.get(c);
+        if (list) scan2(list);
+      }
+    } else {
+      for (const [c, list] of cols) if (c >= start.col && c <= end.col) scan2(list);
+    }
+  }
+};
+var ReverseIndex = class extends AreaIndex {
+  constructor(nodes = []) {
+    super();
+    for (const node of nodes) this.addNode(node);
+  }
+  /** Indexes one more formula's precedents. */
+  addNode(node) {
+    for (const dep of node.deps) this.add(dep, node);
+    for (const dep of node.dynamicDeps) this.add(dep, node);
+  }
+};
+
+// xlsx/formula/engine-prepare.ts
+var CHECK_EVERY = 32;
+var GraphPreparation = class {
+  constructor(workbook, create) {
+    this.workbook = workbook;
+    this.create = create;
+  }
+  workbook;
+  create;
+  reverse = new ReverseIndex();
+  formulas = { dynamic: [], unvalued: [] };
+  sheet = 0;
+  rows;
+  row = 0;
+  cells;
+  finished = false;
+  /**
+   * Adds formulas to the graph until `timeRemaining` (milliseconds, as an idle deadline reports
+   * them) reaches zero, or until every formula is in. Returns true when the graph is complete.
+   */
+  run(timeRemaining) {
+    let visited = 0;
+    while (!this.finished) {
+      const cells = this.cells ?? this.nextRow();
+      if (!cells) continue;
+      const next = cells.next();
+      if (next.done) {
+        this.cells = void 0;
+        continue;
+      }
+      const [col, cell] = next.value;
+      if (cell.formula) this.add(this.create(this.sheet, this.row, col, cell), cell);
+      if (timeRemaining && ++visited % CHECK_EVERY === 0 && timeRemaining() <= 0) break;
+    }
+    return this.finished;
+  }
+  add(node, cell) {
+    this.reverse.addNode(node);
+    if (!node.legacy && !node.arrayRange) this.formulas.dynamic.push(node);
+    if (cell.value === null && !node.keepCached) this.formulas.unvalued.push(node);
+  }
+  /** Moves to the next stored row (and sheet), or marks the walk finished. */
+  nextRow() {
+    for (; ; ) {
+      const sheet = this.workbook.sheets[this.sheet];
+      if (!sheet) {
+        this.finished = true;
+        return void 0;
+      }
+      this.rows ??= sheet.rows.entries();
+      const next = this.rows.next();
+      if (!next.done) {
+        this.row = next.value[0];
+        this.cells = next.value[1].entries();
+        return this.cells;
+      }
+      this.rows = void 0;
+      this.sheet++;
+    }
+  }
+};
+
 // xlsx/formula/text-number.ts
 var MONTHS2 = [
   "jan",
@@ -5831,8 +6049,10 @@ var FINANCIAL_FUNCTIONS = [
 
 // xlsx/formula/references.ts
 function sheetIndex(host, name) {
+  const sheets = host.workbook.sheets;
+  for (let i2 = 0; i2 < sheets.length; i2++) if (sheets[i2]?.name === name) return i2;
   const lower2 = name.toLowerCase();
-  return host.workbook.sheets.findIndex((sheet) => sheet.name.toLowerCase() === lower2);
+  return sheets.findIndex((sheet) => sheet.name.toLowerCase() === lower2);
 }
 function prefixSheets(host, prefix, current) {
   if (!prefix) return [current];
@@ -7402,9 +7622,9 @@ function readBlock(ctx, area, rows2, cols) {
   if (host.readBlock) return host.readBlock(area.sheet, range2);
   return Matrix.build(rows2, cols, (r, c) => ctx.readCell(area.sheet, row2 + r, col + c));
 }
-function shapedMatrices(ctx, values2, sameShape) {
+function shapedMatrices(ctx, values2, sameShape2) {
   let { rows: rows2, cols } = shapeOf(values2[0] ?? null);
-  if (sameShape) {
+  if (sameShape2) {
     for (const value2 of values2) {
       const shape2 = shapeOf(value2);
       if (shape2.rows !== rows2 || shape2.cols !== cols) fail(ERR.VALUE);
@@ -7430,12 +7650,12 @@ function shapedMatrices(ctx, values2, sameShape) {
   });
   return { matrices, total: total2, block: rows2 * cols };
 }
-function matchingCells(ctx, pairs, target2, sameShape) {
+function matchingCells(ctx, pairs, target2, sameShape2) {
   const ranges = pairs.map((p) => p.range);
   const { matrices, total: total2, block } = shapedMatrices(
     ctx,
     target2 === void 0 ? ranges : [...ranges, target2],
-    sameShape
+    sameShape2
   );
   const tests = pairs.map((p) => makeCriteria(scalar(p.criteria)));
   const values2 = matrices[matrices.length - 1];
@@ -7474,7 +7694,7 @@ function indexedCandidates(pairs, matrices) {
   }
   return void 0;
 }
-var matchingValues = (ctx, pairs, target2, sameShape) => matchingCells(ctx, pairs, target2, sameShape).values;
+var matchingValues = (ctx, pairs, target2, sameShape2) => matchingCells(ctx, pairs, target2, sameShape2).values;
 function criteriaPairs(args, from) {
   if ((args.length - from) % 2 !== 0) fail(ERR.VALUE);
   const pairs = [];
@@ -11368,7 +11588,7 @@ var REFERENCE_ARGUMENT = /* @__PURE__ */ new Set([
   "AREAS",
   "ISREF"
 ]);
-var push = (c, area) => {
+var push2 = (c, area) => {
   (c.dynamic > 0 ? c.dynamicDeps : c.deps).push(area);
 };
 function spans(areas) {
@@ -11394,7 +11614,7 @@ function visit(node, c) {
       if (!sheets) return;
       const range2 = specRange(node.ref);
       const target2 = node.spill ? { start: range2.start, end: { ...range2.start } } : range2;
-      for (const sheet of sheets) push(c, { sheet, range: target2 });
+      for (const sheet of sheets) push2(c, { sheet, range: target2 });
       return;
     }
     case "name": {
@@ -11468,7 +11688,7 @@ function visitBinary(node, c) {
       const list = c.dynamic > 0 ? c.dynamicDeps : c.deps;
       const l = list[list.length - 2];
       const r = list[list.length - 1];
-      if (l && r && l.sheet === r.sheet) push(c, spans([l, r])[0]);
+      if (l && r && l.sheet === r.sheet) push2(c, spans([l, r])[0]);
       continue;
     }
     const mentioned = [...c.deps.slice(staticStart), ...c.dynamicDeps.slice(dynamicStart)];
@@ -11484,7 +11704,7 @@ function addStructured(ref, c) {
     sheet: c.sheet,
     row: c.row,
     col: c.col});
-  if (value2 instanceof RefValue) for (const area of value2.areas) push(c, area);
+  if (value2 instanceof RefValue) for (const area of value2.areas) push2(c, area);
 }
 function analyze(ast, host, sheet, row2, col) {
   const c = {
@@ -11508,171 +11728,207 @@ function analyze(ast, host, sheet, row2, col) {
   };
 }
 
-// xlsx/formula/area-index.ts
-var BUCKET_WIDTH = 64;
-var CHUNK_SHIFT = 6;
-var CHUNKS = 64;
-function push2(map, key, value2) {
-  const list = map.get(key);
-  if (list) list.push(value2);
-  else map.set(key, [value2]);
+// xlsx/formula/formula-shape.ts
+var isDigit4 = (code) => code >= 48 && code <= 57;
+function formulaShape(formula) {
+  const starts = [];
+  const ends = [];
+  let hash = 2166136261;
+  for (let i2 = 0; i2 < formula.length; i2++) {
+    let code = formula.charCodeAt(i2);
+    if (isDigit4(code)) {
+      let j = i2 + 1;
+      while (j < formula.length && isDigit4(formula.charCodeAt(j))) j++;
+      starts.push(i2);
+      ends.push(j);
+      i2 = j - 1;
+      code = 0;
+    }
+    hash = Math.imul(hash ^ code, 16777619);
+  }
+  return { hash: hash >>> 0, starts, ends };
 }
-function inner(map, sheet) {
-  let found = map.get(sheet);
-  if (!found) map.set(sheet, found = /* @__PURE__ */ new Map());
-  return found;
+function sameText(a, from, b, at, length) {
+  for (let k = 0; k < length; k++)
+    if (a.charCodeAt(from + k) !== b.charCodeAt(at + k)) return false;
+  return true;
 }
-var AreaIndex = class {
-  cells = /* @__PURE__ */ new Map();
-  chunked = /* @__PURE__ */ new Map();
-  tall = /* @__PURE__ */ new Map();
-  wide = /* @__PURE__ */ new Map();
-  add(area, node) {
-    const { start, end } = area.range;
-    if (start.row === end.row && end.col - start.col + 1 <= BUCKET_WIDTH) {
-      const cells = inner(this.cells, area.sheet);
-      for (let col = start.col; col <= end.col; col++) push2(cells, cellKey(start.row, col), node);
-      return;
+function sameShape(a, as, b, bs) {
+  const runs = as.starts.length;
+  if (runs !== bs.starts.length) return false;
+  let fromA = 0;
+  let fromB = 0;
+  for (let i2 = 0; i2 <= runs; i2++) {
+    const toA = i2 < runs ? as.starts[i2] : a.length;
+    const toB = i2 < runs ? bs.starts[i2] : b.length;
+    if (toA - fromA !== toB - fromB || !sameText(a, fromA, b, fromB, toA - fromA)) return false;
+    fromA = as.ends[i2] ?? 0;
+    fromB = bs.ends[i2] ?? 0;
+  }
+  return true;
+}
+function makeTemplate(formula, shape2) {
+  let tokens;
+  let ast;
+  try {
+    tokens = tokenize(formula);
+    ast = parseTokens(tokens);
+  } catch (e) {
+    if (e instanceof RangeError) return new FormulaError(e.message, -1, "#VALUE!");
+    if (e instanceof FormulaError) return e;
+    throw e;
+  }
+  const { starts } = shape2;
+  const slotted = starts.map(() => false);
+  const refs = /* @__PURE__ */ new Map();
+  let run = 0;
+  for (const token of tokens) {
+    const end = token.start + token.text.length;
+    const first2 = run;
+    while (run < starts.length && starts[run] < end) run++;
+    const ref = token.kind === "ref" ? token.ref : void 0;
+    if (!ref || ref.kind === "cols") continue;
+    const count2 = ref.kind === "cell" ? 1 : 2;
+    if (run - first2 < count2) continue;
+    const at = run - count2;
+    const indexes2 = count2 === 1 ? [at] : [at, at + 1];
+    if (indexes2.some((i2) => formula.charCodeAt(starts[i2]) === 48)) continue;
+    for (const i2 of indexes2) slotted[i2] = true;
+    refs.set(ref, count2 === 1 ? { start: at } : { start: at, end: at + 1 });
+  }
+  return { formula, shape: shape2, ast, slotted, refs };
+}
+function rowsFor(t, formula, shape2) {
+  if (!sameShape(t.formula, t.shape, formula, shape2)) return void 0;
+  const rows2 = [];
+  for (let i2 = 0; i2 < shape2.starts.length; i2++) {
+    const start = shape2.starts[i2];
+    const length = shape2.ends[i2] - start;
+    if (!t.slotted[i2]) {
+      const own = t.shape.starts[i2];
+      if (t.shape.ends[i2] - own !== length) return void 0;
+      if (!sameText(t.formula, own, formula, start, length)) return void 0;
+      rows2.push(-1);
+      continue;
     }
-    const entry = { range: area.range, node };
-    if (end.col - start.col + 1 > BUCKET_WIDTH) {
-      const list = this.wide.get(area.sheet);
-      if (list) list.push(entry);
-      else this.wide.set(area.sheet, [entry]);
-      return;
+    if (length > 7 || formula.charCodeAt(start) === 48) return void 0;
+    let row2 = 0;
+    for (let k = start; k < start + length; k++) row2 = row2 * 10 + formula.charCodeAt(k) - 48;
+    if (row2 < 1 || row2 > MAX_ROW + 1) return void 0;
+    rows2.push(row2 - 1);
+  }
+  return rows2;
+}
+function shiftSpec(spec2, slots, rows2) {
+  const startRow = rows2[slots.start];
+  const endRow = slots.end === void 0 ? startRow : rows2[slots.end];
+  if (startRow === spec2.start.row && endRow === spec2.end.row) return spec2;
+  const { start: from, end: to } = spec2;
+  const start = { row: startRow, col: from.col, rowAbs: from.rowAbs, colAbs: from.colAbs };
+  if (slots.end === void 0) return { kind: spec2.kind, start, end: start };
+  const end = { row: endRow, col: to.col, rowAbs: to.rowAbs, colAbs: to.colAbs };
+  return { kind: spec2.kind, start, end };
+}
+function copyTree(node, t, rows2) {
+  switch (node.type) {
+    case "ref": {
+      const slots = node.ref ? t.refs.get(node.ref) : void 0;
+      if (!slots || !node.ref) return node;
+      const ref = shiftSpec(node.ref, slots, rows2);
+      if (ref === node.ref) return node;
+      const copy2 = { type: "ref" };
+      if (node.prefix) copy2.prefix = node.prefix;
+      copy2.ref = ref;
+      if (node.spill) copy2.spill = true;
+      return copy2;
     }
-    const first2 = start.row >> CHUNK_SHIFT;
-    const last = end.row >> CHUNK_SHIFT;
-    if (last - first2 + 1 > CHUNKS) {
-      const cols2 = inner(this.tall, area.sheet);
-      for (let c = start.col; c <= end.col; c++) push2(cols2, c, entry);
-      return;
+    case "unary":
+    case "percent": {
+      const operand4 = copyTree(node.operand, t, rows2);
+      if (operand4 === node.operand) return node;
+      return node.type === "unary" ? { type: "unary", op: node.op, operand: operand4 } : { type: "percent", operand: operand4 };
     }
-    const cols = inner(this.chunked, area.sheet);
-    for (let c = start.col; c <= end.col; c++) {
-      let chunks = cols.get(c);
-      if (!chunks) cols.set(c, chunks = /* @__PURE__ */ new Map());
-      for (let k = first2; k <= last; k++) push2(chunks, k, entry);
+    case "binary": {
+      const left2 = copyTree(node.left, t, rows2);
+      const right2 = copyTree(node.right, t, rows2);
+      if (left2 === node.left && right2 === node.right) return node;
+      return { type: "binary", op: node.op, left: left2, right: right2 };
+    }
+    case "call": {
+      const args = copyAll(node.args, t, rows2);
+      if (args === node.args) return node;
+      return { type: "call", name: node.name, rawName: node.rawName, args };
     }
+    case "invoke": {
+      const callee = copyTree(node.callee, t, rows2);
+      const args = copyAll(node.args, t, rows2);
+      if (callee === node.callee && args === node.args) return node;
+      return { type: "invoke", callee, args };
+    }
+    default:
+      return node;
   }
-  /** Items whose areas intersect `range` on `sheet` (each once). */
-  dependents(sheet, range2, out) {
-    const found = out instanceof Set ? out : /* @__PURE__ */ new Set();
-    this.collect(sheet, range2, found);
-    if (Array.isArray(out)) for (const node of found) out.push(node);
+}
+function copyAll(nodes, t, rows2) {
+  let out;
+  for (let i2 = 0; i2 < nodes.length; i2++) {
+    const node = nodes[i2];
+    const copy2 = copyTree(node, t, rows2);
+    if (copy2 !== node && !out) out = nodes.slice(0, i2);
+    out?.push(copy2);
+  }
+  return out ?? nodes;
+}
+function fromTemplate(t, formula, shape2) {
+  const rows2 = rowsFor(t, formula, shape2);
+  return rows2 ? copyTree(t.ast, t, rows2) : void 0;
+}
+
+// xlsx/formula/parse-cache.ts
+var MAX_TEMPLATE_LENGTH = 2048;
+var MAX_ENTRIES = 1e5;
+var MAX_TEMPLATES = 1e4;
+var NO_RUNS = { hash: 0, starts: [], ends: [] };
+var treeOf = (made) => "ast" in made ? made.ast : made;
+var ParseCache = class {
+  byText = /* @__PURE__ */ new Map();
+  templates = /* @__PURE__ */ new Map();
+  parse(formula) {
+    let ast = this.byText.get(formula);
+    if (ast) return ast;
+    ast = this.parseNew(formula);
+    if (this.byText.size > MAX_ENTRIES) this.byText.clear();
+    this.byText.set(formula, ast);
+    return ast;
   }
-  collect(sheet, range2, out) {
-    const { start, end } = range2;
-    const check3 = (list) => {
-      if (list) {
-        for (const entry of list) if (rangesIntersect(entry.range, range2)) out.add(entry.node);
-      }
-    };
-    const cells = this.cells.get(sheet);
-    if (cells) {
-      const size = (end.row - start.row + 1) * (end.col - start.col + 1);
-      if (size <= 4096) {
-        for (let r = start.row; r <= end.row; r++) {
-          for (let c = start.col; c <= end.col; c++) {
-            const list = cells.get(cellKey(r, c));
-            if (list) for (const node of list) out.add(node);
-          }
-        }
-      } else {
-        for (const [key, list] of cells) {
-          const { row: row2, col } = keyToAddress(key);
-          if (row2 >= start.row && row2 <= end.row && col >= start.col && col <= end.col)
-            for (const node of list) out.add(node);
-        }
-      }
-    }
-    const columns = (map, visit2) => {
-      if (!map) return;
-      if (end.col - start.col + 1 <= map.size) {
-        for (let c = start.col; c <= end.col; c++) if (map.has(c)) visit2(c);
-      } else for (const c of map.keys()) if (c >= start.col && c <= end.col) visit2(c);
-    };
-    const chunked = this.chunked.get(sheet);
-    const first2 = start.row >> CHUNK_SHIFT;
-    const last = end.row >> CHUNK_SHIFT;
-    columns(chunked, (c) => {
-      const chunks = chunked?.get(c);
-      if (last - first2 + 1 <= chunks.size) {
-        for (let k = first2; k <= last; k++) check3(chunks.get(k));
-      } else for (const [k, list] of chunks) if (k >= first2 && k <= last) check3(list);
-    });
-    const tall = this.tall.get(sheet);
-    columns(tall, (c) => check3(tall?.get(c)));
-    check3(this.wide.get(sheet));
-  }
-};
-
-// xlsx/formula/graph-index.ts
-var ColumnIndex = class {
-  sheets = /* @__PURE__ */ new Map();
-  constructor(nodes) {
-    for (const node of nodes) {
-      let cols = this.sheets.get(node.sheet);
-      if (!cols) this.sheets.set(node.sheet, cols = /* @__PURE__ */ new Map());
-      let list = cols.get(node.col);
-      if (!list) cols.set(node.col, list = []);
-      list.push(node);
-    }
-    for (const cols of this.sheets.values())
-      for (const list of cols.values()) list.sort((a, b) => a.row - b.row);
-  }
-  nodesIn(area, out) {
-    const cols = this.sheets.get(area.sheet);
-    if (!cols) return;
-    const { start, end } = area.range;
-    const width = end.col - start.col + 1;
-    const scan2 = (list) => {
-      let lo = 0;
-      let hi = list.length;
-      while (lo < hi) {
-        const mid = lo + hi >> 1;
-        if (list[mid].row < start.row) lo = mid + 1;
-        else hi = mid;
-      }
-      for (let i2 = lo; i2 < list.length; i2++) {
-        const node = list[i2];
-        if (node.row > end.row) break;
-        out.push(node);
-      }
-    };
-    if (width <= cols.size) {
-      for (let c = start.col; c <= end.col; c++) {
-        const list = cols.get(c);
-        if (list) scan2(list);
-      }
-    } else {
-      for (const [c, list] of cols) if (c >= start.col && c <= end.col) scan2(list);
-    }
-  }
-};
-var ReverseIndex = class extends AreaIndex {
-  constructor(nodes) {
-    super();
-    for (const node of nodes) {
-      for (const dep of node.deps) this.add(dep, node);
-      for (const dep of node.dynamicDeps) this.add(dep, node);
-    }
-  }
-};
-
-// xlsx/formula/sheet-scan.ts
-function scanRange(sheet, range2, visit2) {
-  const { start, end } = range2;
-  const rowCount = end.row - start.row + 1;
-  const rows2 = rowCount <= sheet.rows.size * 2 ? null : [...sheet.rows.keys()].filter((r) => r >= start.row && r <= end.row).sort((a, b) => a - b);
-  const visitRow = (r) => {
-    const cells = sheet.rows.get(r);
-    if (!cells || cells.size === 0) return;
-    const colCount = end.col - start.col + 1;
-    if (colCount <= cells.size * 2) {
-      for (let c = start.col; c <= end.col; c++) {
-        const cell = cells.get(c);
-        if (cell) visit2(cell, r, c);
+  parseNew(formula) {
+    if (formula.length > MAX_TEMPLATE_LENGTH) return treeOf(makeTemplate(formula, NO_RUNS));
+    const shape2 = formulaShape(formula);
+    const template = this.templates.get(shape2.hash);
+    const reused = template && fromTemplate(template, formula, shape2);
+    if (reused) return reused;
+    const made = makeTemplate(formula, shape2);
+    if (!template && "ast" in made) {
+      if (this.templates.size > MAX_TEMPLATES) this.templates.clear();
+      this.templates.set(shape2.hash, made);
+    }
+    return treeOf(made);
+  }
+};
+
+// xlsx/formula/sheet-scan.ts
+function scanRange(sheet, range2, visit2) {
+  const { start, end } = range2;
+  const rowCount = end.row - start.row + 1;
+  const rows2 = rowCount <= sheet.rows.size * 2 ? null : [...sheet.rows.keys()].filter((r) => r >= start.row && r <= end.row).sort((a, b) => a - b);
+  const visitRow = (r) => {
+    const cells = sheet.rows.get(r);
+    if (!cells || cells.size === 0) return;
+    const colCount = end.col - start.col + 1;
+    if (colCount <= cells.size * 2) {
+      for (let c = start.col; c <= end.col; c++) {
+        const cell = cells.get(c);
+        if (cell) visit2(cell, r, c);
       }
       return;
     }
@@ -11796,7 +12052,7 @@ var EngineHost = class {
   options;
   nodes = /* @__PURE__ */ new Map();
   footprints = /* @__PURE__ */ new Set();
-  astCache = /* @__PURE__ */ new Map();
+  parsed = new ParseCache();
   boundsCache = /* @__PURE__ */ new Map();
   inProgress = /* @__PURE__ */ new Set();
   cycles = /* @__PURE__ */ new Set();
@@ -11820,6 +12076,8 @@ var EngineHost = class {
   evaluations = 0;
   built = false;
   needsFull = false;
+  /** No recalculation has run since the workbook was opened: stored values may stand. */
+  fresh = true;
   // ---- EvalHost ----
   readCell(sheet, row2, col) {
     const cell = this.workbook.sheets[sheet]?.rows.get(row2)?.get(col);
@@ -11908,19 +12166,7 @@ var EngineHost = class {
     return this.workbook.sheets[sheet]?.rows.get(row2)?.get(col)?.formula;
   }
   parse(formula) {
-    let ast = this.astCache.get(formula);
-    if (!ast) {
-      try {
-        ast = parseFormula(formula);
-      } catch (e) {
-        if (e instanceof RangeError) ast = new FormulaError(e.message, -1, "#VALUE!");
-        else if (!(e instanceof FormulaError)) throw e;
-        else ast = e;
-      }
-      if (this.astCache.size > 1e5) this.astCache.clear();
-      this.astCache.set(formula, ast);
-    }
-    return ast;
+    return this.parsed.parse(formula);
   }
   now() {
     return this.options.now ? this.options.now() : /* @__PURE__ */ new Date();
@@ -11929,20 +12175,6 @@ var EngineHost = class {
     return this.options.random ? this.options.random() : Math.random();
   }
   // ---- graph ----
-  build() {
-    this.nodes.clear();
-    this.footprints.clear();
-    this.footprintIndex = void 0;
-    this.workbook.sheets.forEach((sheet, s) => {
-      for (const [row2, cells] of sheet.rows) {
-        for (const [col, cell] of cells) {
-          if (cell.formula) this.createNode(s, row2, col, cell, true);
-        }
-      }
-    });
-    this.built = true;
-    this.graphChanged();
-  }
   createNode(sheet, row2, col, cell, initial) {
     const formula = cell.formula ?? "";
     const parsed = this.parse(formula);
@@ -11971,6 +12203,14 @@ var EngineHost = class {
     map.set(cellKey(row2, col), node);
     return node;
   }
+  /** Parses a node's text again after a structural edit rewrote it (see `FormulaNode.stale`). */
+  refreshAst(node) {
+    const parsed = this.parse(node.formula);
+    delete node.stale;
+    delete node.parseError;
+    node.ast = parsed instanceof FormulaError ? void 0 : parsed;
+    if (parsed instanceof FormulaError && parsed.code) node.parseError = err(parsed.code);
+  }
   removeNode(node, changed) {
     const sheet = this.workbook.sheets[node.sheet];
     if (node.spill && sheet) {
@@ -12401,6 +12641,7 @@ var EngineCore = class extends EngineHost {
     return { host: this, sheet, row: row2, col, scope: void 0, depth: 0, root, legacy };
   }
   evaluateFormula(node) {
+    if (node.stale) this.refreshAst(node);
     if (!node.ast) return node.parseError ?? ERR.NAME;
     const ast = node.ast;
     const frame = this.frameFor(node.sheet, node.row, node.col, ast, node.legacy);
@@ -12418,20 +12659,363 @@ var EngineCore = class extends EngineHost {
   }
 };
 
+// xlsx/formula/shift-graph.ts
+var POSITIONAL = /* @__PURE__ */ new Set(["ROW", "COLUMN"]);
+var DESCRIPTIVE = /* @__PURE__ */ new Set(["FORMULATEXT", "CELL", "SHEET"]);
+var traitsCache = /* @__PURE__ */ new WeakMap();
+function astTraits(ast) {
+  const cached = traitsCache.get(ast);
+  if (cached) return cached;
+  const sheets = /* @__PURE__ */ new Set();
+  const traits = { complex: false, opaque: false, positional: false, descriptive: false, sheets };
+  const stack2 = [ast];
+  while (stack2.length) {
+    const node = stack2.pop();
+    switch (node.type) {
+      case "ref":
+        if (node.prefix) {
+          sheets.add(node.prefix.sheet.toLowerCase());
+          if (node.prefix.sheet2 !== void 0) {
+            sheets.add(node.prefix.sheet2.toLowerCase());
+            traits.complex = true;
+          }
+        }
+        break;
+      case "name":
+        if (node.prefix) sheets.add(node.prefix.sheet.toLowerCase());
+        traits.complex = true;
+        break;
+      case "structured":
+        traits.complex = true;
+        break;
+      case "unary":
+      case "percent":
+        stack2.push(node.operand);
+        break;
+      case "binary":
+        stack2.push(node.left, node.right);
+        break;
+      case "call":
+        if (POSITIONAL.has(node.name)) traits.positional = true;
+        if (DESCRIPTIVE.has(node.name)) traits.descriptive = true;
+        if (!getFunction(node.name)) traits.complex = traits.opaque = true;
+        stack2.push(...node.args);
+        break;
+      case "invoke":
+        stack2.push(node.callee, ...node.args);
+        break;
+    }
+  }
+  traitsCache.set(ast, traits);
+  return traits;
+}
+function intervalDelta(a, b, shift2) {
+  const { at, count: count2 } = shift2;
+  if (count2 > 0) {
+    if (b < at) return 0;
+    if (a < at) return void 0;
+    return b + count2 > (shift2.axis === "row" ? MAX_ROW : MAX_COL) ? void 0 : count2;
+  }
+  const last = at - count2 - 1;
+  if (b < at) return 0;
+  if (a > last) return count2;
+  return void 0;
+}
+function areaDelta(area, sheet, shift2) {
+  if (area.sheet !== sheet) return 0;
+  const { start, end } = area.range;
+  return shift2.axis === "row" ? intervalDelta(start.row, end.row, shift2) : intervalDelta(start.col, end.col, shift2);
+}
+function movedRange(range2, axis, delta) {
+  if (delta === 0) return range2;
+  return axis === "row" ? {
+    start: { row: range2.start.row + delta, col: range2.start.col },
+    end: { row: range2.end.row + delta, col: range2.end.col }
+  } : {
+    start: { row: range2.start.row, col: range2.start.col + delta },
+    end: { row: range2.end.row, col: range2.end.col + delta }
+  };
+}
+function reachesEdit(areas, sheet, shift2) {
+  for (const area of areas) {
+    if (area.sheet !== sheet) continue;
+    if ((shift2.axis === "row" ? area.range.end.row : area.range.end.col) >= shift2.at) return true;
+  }
+  return false;
+}
+function intersectionMoves(area, delta, pos, nodeDelta, axis) {
+  if (delta === nodeDelta) return false;
+  const { start, end } = area.range;
+  const a = axis === "row" ? start.row : start.col;
+  const b = axis === "row" ? end.row : end.col;
+  if (a === b) return false;
+  return pos >= a && pos <= b || pos + nodeDelta >= a + delta && pos + nodeDelta <= b + delta;
+}
+
+// xlsx/formula/engine-structure.ts
+var sameAreas = (a, b) => a.length === b.length && a.every((x, i2) => {
+  const y = b[i2];
+  return x.sheet === y.sheet && sameRange(x.range, y.range);
+});
+var EngineStructure = class extends EngineCore {
+  /** Formulas a structural edit left to recalculate (with their dependents) on the next pass. */
+  structuralSeeds = /* @__PURE__ */ new Set();
+  /** Whether the graph describes the workbook as it was before the edit just reported. */
+  graphReady() {
+    return this.built && !this.needsFull;
+  }
+  /** Parses a node's current text again and recomputes its precedents. */
+  reanalyze(node) {
+    const parsed = this.parse(node.formula);
+    delete node.stale;
+    delete node.parseError;
+    if (parsed instanceof FormulaError) {
+      node.ast = void 0;
+      if (parsed.code) node.parseError = err(parsed.code);
+      node.deps = [];
+      node.dynamicDeps = [];
+      return;
+    }
+    node.ast = parsed;
+    const found = analyze(parsed, this, node.sheet, node.row, node.col);
+    node.deps = found.deps;
+    node.dynamicDeps = found.dynamicDeps;
+    node.volatile = found.volatile;
+    node.unsupported = found.unsupported;
+  }
+  /**
+   * Moves the graph for rows or columns inserted or deleted on `sheet`, after the workbook was
+   * changed (cells moved, formulas rewritten). Spills on the sheet, array formulas the edit cuts
+   * and anything unexpected fall back to a rebuild on the next recalculation.
+   */
+  shiftCells(sheet, shift2) {
+    if (!this.graphReady() || !this.shiftable(sheet, shift2)) {
+      this.invalidate();
+      return;
+    }
+    const ws = this.workbook.sheets[sheet];
+    const own = this.nodes.get(sheet);
+    if (!ws) return;
+    const moved = /* @__PURE__ */ new Map();
+    if (own) {
+      const next = /* @__PURE__ */ new Map();
+      for (const node of own.values()) {
+        const pos = shift2.axis === "row" ? node.row : node.col;
+        const delta = intervalDelta(pos, pos, shift2);
+        if (delta === void 0) {
+          this.dropNode(node);
+          continue;
+        }
+        if (delta !== 0) {
+          moved.set(node, delta);
+          if (shift2.axis === "row") node.row += delta;
+          else node.col += delta;
+        }
+        next.set(cellKey(node.row, node.col), node);
+      }
+      this.nodes.set(sheet, next);
+    }
+    for (const map of this.nodes.values())
+      for (const node of map.values()) {
+        if (!this.shiftNode(node, sheet, shift2, moved.get(node) ?? 0)) {
+          this.invalidate();
+          return;
+        }
+      }
+    this.boundsCache.clear();
+    this.graphChanged();
+  }
+  /** No spill or stale spilled value on the sheet, and no array formula the edit cuts. */
+  shiftable(sheet, shift2) {
+    for (const node of this.footprints) {
+      if (node.sheet !== sheet) continue;
+      if (node.spill || node.blockedSpill) return false;
+      if (node.arrayRange && areaDelta({ sheet, range: node.arrayRange }, sheet, shift2) === void 0)
+        return false;
+    }
+    const ws = this.workbook.sheets[sheet];
+    let spilled = false;
+    ws?.rows.forEach((cells) => {
+      if (!spilled) cells.forEach((cell) => spilled ||= isSpilledCell(cell));
+    });
+    return !spilled;
+  }
+  dropNode(node) {
+    this.structuralSeeds.delete(node);
+    this.cycles.delete(node);
+    this.footprints.delete(node);
+  }
+  /** Updates one formula for the edit; false when the graph cannot follow it. */
+  shiftNode(node, sheet, shift2, nodeDelta) {
+    const cell = this.workbook.sheets[node.sheet]?.rows.get(node.row)?.get(node.col);
+    if (cell?.formula === void 0) return false;
+    if (node.arrayRange) {
+      const delta = areaDelta({ sheet: node.sheet, range: node.arrayRange }, sheet, shift2);
+      if (delta === void 0) return false;
+      node.arrayRange = movedRange(node.arrayRange, shift2.axis, delta);
+      if (!cell.arrayRange || !sameRange(node.arrayRange, normalizeRange(cell.arrayRange)))
+        return false;
+    }
+    const changed = cell.formula !== node.formula;
+    const traits = node.ast && astTraits(node.ast);
+    const reached = reachesEdit(node.deps, sheet, shift2) || reachesEdit(node.dynamicDeps, sheet, shift2);
+    if (!changed && !reached && nodeDelta === 0 && !traits?.descriptive && !traits?.opaque)
+      return true;
+    if (traits?.complex) {
+      node.formula = cell.formula;
+      this.reanalyze(node);
+      this.structuralSeeds.add(node);
+      return true;
+    }
+    const pos = shift2.axis === "row" ? node.row - nodeDelta : node.col - nodeDelta;
+    const moves = { seed: !!traits?.descriptive, moved: false, cut: false };
+    const deps = this.moveAreas(node.deps, sheet, shift2, pos, nodeDelta, moves);
+    const dynamicDeps = this.moveAreas(node.dynamicDeps, sheet, shift2, pos, nodeDelta, moves);
+    const { cut, moved: anyMoved } = moves;
+    let seed = moves.seed;
+    if (cut || changed !== anyMoved) {
+      node.formula = cell.formula;
+      this.reanalyze(node);
+      this.structuralSeeds.add(node);
+      return true;
+    }
+    if (traits?.positional && (anyMoved || nodeDelta !== 0)) seed = true;
+    node.deps = deps;
+    node.dynamicDeps = dynamicDeps;
+    if (changed) {
+      node.formula = cell.formula;
+      node.stale = true;
+    }
+    if (seed) this.structuralSeeds.add(node);
+    return true;
+  }
+  /**
+   * Areas moved for the edit (the same list when none moves). Records in `moves` whether one
+   * moved, one was cut (deleted, widened, pushed off the grid) and whether implicit intersection
+   * with one can now pick another cell.
+   */
+  moveAreas(list, sheet, shift2, pos, nodeDelta, moves) {
+    let out;
+    for (let i2 = 0; i2 < list.length; i2++) {
+      const area = list[i2];
+      const delta = areaDelta(area, sheet, shift2);
+      if (delta === void 0) {
+        moves.cut = true;
+        continue;
+      }
+      if (intersectionMoves(area, delta, pos, nodeDelta, shift2.axis)) moves.seed = true;
+      if (delta === 0) continue;
+      moves.moved = true;
+      out ??= list.slice();
+      out[i2] = { sheet: area.sheet, range: movedRange(area.range, shift2.axis, delta) };
+    }
+    return out ?? list;
+  }
+  /**
+   * Follows a sheet rename (`from` to `to`, formulas already rewritten): precedents are kept by
+   * sheet index, so only rewritten formulas need their text parsed again, and only formulas that
+   * name the new sheet without having been rewritten (previously unresolved), describe sheets
+   * (CELL, SHEET, FORMULATEXT) or read defined names whose areas changed are recalculated.
+   */
+  renameSheet(from, to) {
+    if (!this.graphReady()) {
+      this.invalidate();
+      return;
+    }
+    const target2 = to.toLowerCase();
+    let depsChanged = false;
+    for (const map of this.nodes.values())
+      for (const node of map.values()) {
+        const cell = this.workbook.sheets[node.sheet]?.rows.get(node.row)?.get(node.col);
+        if (cell?.formula === void 0) {
+          this.invalidate();
+          return;
+        }
+        const changed = cell.formula !== node.formula;
+        const traits = node.ast && astTraits(node.ast);
+        node.formula = cell.formula;
+        if (traits?.complex || !changed && traits?.sheets.has(target2)) {
+          const deps = node.deps;
+          const dynamicDeps = node.dynamicDeps;
+          this.reanalyze(node);
+          const same4 = sameAreas(deps, node.deps) && sameAreas(dynamicDeps, node.dynamicDeps);
+          if (!same4) depsChanged = true;
+          if (!same4 || !traits?.complex) this.structuralSeeds.add(node);
+        } else if (changed) node.stale = true;
+        if (traits?.descriptive || traits?.opaque) this.structuralSeeds.add(node);
+      }
+    if (depsChanged) this.graphChanged();
+  }
+  /** Takes the formulas queued by structural edits. */
+  takeStructuralSeeds(into) {
+    for (const node of this.structuralSeeds)
+      if (this.nodes.get(node.sheet)?.get(cellKey(node.row, node.col)) === node) into.add(node);
+    this.structuralSeeds.clear();
+  }
+};
+
 // xlsx/formula/engine.ts
-var Engine = class extends EngineCore {
+var Engine = class extends EngineStructure {
+  preparation;
+  /** The prepared formulas the first recalculation checks (see `trustsStoredValues`). */
+  prepared;
+  // ---- the graph ----
+  prepare(timeRemaining) {
+    if (this.built || this.needsFull) return true;
+    this.preparation ??= this.startPreparation();
+    if (!this.preparation.run(timeRemaining)) return false;
+    this.finishPreparation(this.preparation);
+    return true;
+  }
+  discardPreparation() {
+    if (!this.fresh || this.needsFull) return;
+    this.preparation = void 0;
+    this.prepared = void 0;
+    this.structuralSeeds.clear();
+    this.nodes.clear();
+    this.footprints.clear();
+    this.graphChanged();
+    this.built = false;
+  }
+  /** Completes the graph, continuing a preparation that is under way. */
+  build() {
+    const preparation = this.preparation ?? this.startPreparation();
+    preparation.run();
+    this.finishPreparation(preparation);
+  }
+  startPreparation() {
+    this.nodes.clear();
+    this.footprints.clear();
+    this.footprintIndex = void 0;
+    this.prepared = void 0;
+    return new GraphPreparation(
+      this.workbook,
+      (s, row2, col, cell) => this.createNode(s, row2, col, cell, true)
+    );
+  }
+  finishPreparation(preparation) {
+    this.preparation = void 0;
+    this.built = true;
+    this.graphChanged();
+    this.reverseIndex = preparation.reverse;
+    this.prepared = preparation.formulas;
+  }
   // ---- recalculation ----
   recalculateAll() {
+    this.fresh = false;
+    this.prepared = void 0;
     if (this.needsFull) this.releaseAllSpills();
     if (!this.built || this.needsFull) this.build();
     this.needsFull = false;
+    this.structuralSeeds.clear();
     this.cycles = /* @__PURE__ */ new Set();
     this.run(new Set(this.allNodes()), true);
   }
   recalculateFrom(changes) {
     const seeds = /* @__PURE__ */ new Set();
-    if (!this.built && !this.needsFull) {
-      this.build();
+    if (this.fresh && !this.needsFull) {
+      this.fresh = false;
+      if (!this.built) this.build();
       if (!this.trustsStoredValues(changes, seeds)) {
         this.recalculateAll();
         return;
@@ -12475,6 +13059,7 @@ var Engine = class extends EngineCore {
       }
     }
     if (structural) this.graphChanged();
+    this.takeStructuralSeeds(seeds);
     const reverse = this.reverse();
     for (const area of changed) reverse.dependents(area.sheet, area.range, seeds);
     for (const node of this.allNodes()) if (node.volatile) seeds.add(node);
@@ -12486,13 +13071,18 @@ var Engine = class extends EngineCore {
    * without a value into `missing`.
    */
   trustsStoredValues(changes, missing) {
+    const prepared = this.prepared;
+    this.prepared = void 0;
+    if (!prepared) return false;
     const changed = new Set(changes.map((c) => `${c.sheet}:${cellKey(c.row, c.col)}`));
-    for (const node of this.allNodes()) {
-      const legacyOrArray = node.legacy || node.arrayRange;
-      if (!legacyOrArray && !changed.has(`${node.sheet}:${cellKey(node.row, node.col)}`))
+    const current = (node) => this.nodes.get(node.sheet)?.get(cellKey(node.row, node.col)) === node;
+    for (const node of prepared.dynamic) {
+      if (current(node) && !changed.has(`${node.sheet}:${cellKey(node.row, node.col)}`))
         return false;
+    }
+    for (const node of prepared.unvalued) {
       const cell = this.workbook.sheets[node.sheet]?.rows.get(node.row)?.get(node.col);
-      if (cell && cell.value === null && !node.keepCached) missing.add(node);
+      if (current(node) && cell && cell.value === null) missing.add(node);
     }
     return true;
   }
@@ -12506,7 +13096,10 @@ var Engine = class extends EngineCore {
     return !!anchor?.spill && rangeHas(anchor.spill, row2, col);
   }
   invalidate() {
+    this.structuralSeeds.clear();
     this.releaseAllSpills();
+    this.preparation = void 0;
+    this.prepared = void 0;
     this.nodes.clear();
     this.footprints.clear();
     this.graphChanged();
@@ -12551,7 +13144,7 @@ function createCalcEngine(workbook, options = {}) {
   return new Engine(workbook, options);
 }
 
-// xlsx/formula/transform.ts
+// xlsx/formula/ref-text.ts
 function safeTokens(formula) {
   try {
     return tokenize(formula);
@@ -12570,50 +13163,26 @@ function formatRefSpec(spec2) {
   if (spec2.kind === "cell") return a;
   return `${a}:${cornerText(spec2.end, spec2.kind)}`;
 }
-function rewrite(token, ref) {
+function rewriteRef(token, ref) {
   const prefix = token.prefix?.text ?? "";
   if (!ref) return `${prefix}#REF!`;
   return `${prefix}${formatRefSpec(ref)}${token.spill ? "#" : ""}`;
 }
 var sameSpec = (a, b) => a.kind === b.kind && a.start.row === b.start.row && a.start.col === b.start.col && a.end.row === b.end.row && a.end.col === b.end.col;
-function translateFormula(formula, dRow, dCol) {
-  const tokens = safeTokens(formula);
-  if (!tokens) return formula;
-  for (const token of tokens) {
-    if (token.kind !== "ref" || !token.ref) continue;
-    const spec2 = token.ref;
-    const move = (c) => {
-      const row2 = spec2.kind === "cols" || c.rowAbs ? c.row : c.row + dRow;
-      const col = spec2.kind === "rows" || c.colAbs ? c.col : c.col + dCol;
-      if (row2 < 0 || row2 > MAX_ROW || col < 0 || col > MAX_COL) return void 0;
-      return { ...c, row: row2, col };
-    };
-    const start = move(spec2.start);
-    const end = move(spec2.end);
-    const next = start && end ? { kind: spec2.kind, start, end } : void 0;
-    if (next && sameSpec(next, spec2)) continue;
-    token.text = rewrite(token, next);
-  }
-  return joinTokens(tokens);
+var needsQuote = (name) => !/^[A-Za-z_¡-￿][A-Za-z0-9_.¡-￿]*$/.test(name) || /^[A-Za-z]{1,3}\d+$/.test(name) || /^(?:R\d*C?\d*|C\d*)$/i.test(name) || /^(?:TRUE|FALSE)$/i.test(name);
+function prefixText(prefix) {
+  const sheets = prefix.sheet2 !== void 0 ? `${prefix.sheet}:${prefix.sheet2}` : prefix.sheet;
+  const book = prefix.book !== void 0 ? `[${prefix.book}]` : "";
+  const quote = needsQuote(prefix.sheet) || prefix.sheet2 !== void 0 && needsQuote(prefix.sheet2);
+  return quote ? `'${(book + sheets).replace(/'/g, "''")}'!` : `${book}${sheets}!`;
 }
-var sheetMatches = (prefix, formulaSheet, sheet) => {
-  if (prefix?.book !== void 0) return false;
-  const name = prefix ? prefix.sheet : formulaSheet;
-  return name.toLowerCase() === sheet.toLowerCase();
-};
-function shiftInterval(a, b, at, count2, max) {
-  if (count2 > 0) {
-    const na2 = a >= at ? a + count2 : a;
-    const nb2 = b >= at ? b + count2 : b;
-    if (nb2 > max) return na2 > max ? void 0 : [na2, max];
-    return [na2, nb2];
-  }
-  const n = -count2;
-  const last = at + n - 1;
-  if (a >= at && b <= last) return void 0;
-  const na = a < at ? a : a <= last ? at : a - n;
-  const nb = b < at ? b : b <= last ? at - 1 : b - n;
-  return [na, nb];
+
+// xlsx/formula/shift-formula.ts
+var templates = /* @__PURE__ */ new Map();
+var MAX_TEMPLATES2 = 2e5;
+function remember(text2, template) {
+  if (templates.size >= MAX_TEMPLATES2) templates.clear();
+  templates.set(text2, template);
 }
 function mergeSpacedAreas(tokens) {
   const out = [];
@@ -12640,63 +13209,145 @@ function mergeSpacedAreas(tokens) {
   }
   return out;
 }
-function shiftFormula(formula, formulaSheet, spec2) {
-  if (spec2.count === 0) return formula;
+function templateOf(formula) {
+  const cached = templates.get(formula);
+  if (cached !== void 0) return cached;
   const raw = safeTokens(formula);
-  if (!raw) return formula;
-  const tokens = mergeSpacedAreas(raw);
-  const isRow = spec2.axis === "row";
-  for (const token of tokens) {
-    if (token.kind !== "ref" || !token.ref || !sheetMatches(token.prefix, formulaSheet, spec2.sheet))
-      continue;
-    const ref = token.ref;
-    if (isRow && ref.kind === "cols" || !isRow && ref.kind === "rows") continue;
-    const startFirst = isRow ? ref.start.row <= ref.end.row : ref.start.col <= ref.end.col;
-    const lo = startFirst ? ref.start : ref.end;
-    const hi = startFirst ? ref.end : ref.start;
-    const shifted2 = shiftInterval(
-      isRow ? lo.row : lo.col,
-      isRow ? hi.row : hi.col,
-      spec2.at,
-      spec2.count,
-      isRow ? MAX_ROW : MAX_COL
-    );
-    let next;
-    if (shifted2) {
-      const [a, b] = shifted2;
-      const nlo = isRow ? { ...lo, row: a } : { ...lo, col: a };
-      const nhi = isRow ? { ...hi, row: b } : { ...hi, col: b };
-      next = { kind: ref.kind, start: startFirst ? nlo : nhi, end: startFirst ? nhi : nlo };
-      if (ref.kind === "cell") next.end = next.start;
-    }
-    if (next && sameSpec(next, ref)) continue;
-    token.text = rewrite(token, next);
+  let template = null;
+  if (raw) {
+    template = [];
+    let literal2 = "";
+    for (const token of mergeSpacedAreas(raw)) {
+      if (token.kind !== "ref" && !(token.kind === "name" && token.prefix)) {
+        literal2 += token.text;
+        continue;
+      }
+      if (literal2) template.push(literal2);
+      literal2 = "";
+      const part = { kind: token.kind, text: token.text };
+      if (token.prefix) {
+        part.prefix = token.prefix;
+        if (token.prefix.book === void 0) part.sheet = token.prefix.sheet.toLowerCase();
+      }
+      if (token.ref) part.ref = token.ref;
+      if (token.spill) part.spill = true;
+      template.push(part);
+    }
+    if (literal2) template.push(literal2);
+  }
+  remember(formula, template);
+  return template;
+}
+function rewriteTemplate(formula, rewrite) {
+  const template = templateOf(formula);
+  if (!template) return formula;
+  let next;
+  for (let i2 = 0; i2 < template.length; i2++) {
+    const part = template[i2];
+    if (typeof part === "string") continue;
+    const changed = rewrite(part);
+    if (!changed) continue;
+    next ??= template.slice();
+    next[i2] = changed;
+  }
+  if (!next) return formula;
+  const text2 = next.map((part) => typeof part === "string" ? part : part.text).join("");
+  remember(text2, next);
+  return text2;
+}
+function shiftInterval(a, b, at, count2, max) {
+  if (count2 > 0) {
+    const na2 = a >= at ? a + count2 : a;
+    const nb2 = b >= at ? b + count2 : b;
+    if (nb2 > max) return na2 > max ? void 0 : [na2, max];
+    return [na2, nb2];
   }
-  return joinTokens(tokens);
+  const n = -count2;
+  const last = at + n - 1;
+  if (a >= at && b <= last) return void 0;
+  const na = a < at ? a : a <= last ? at : a - n;
+  const nb = b < at ? b : b <= last ? at - 1 : b - n;
+  return [na, nb];
 }
-var needsQuote = (name) => !/^[A-Za-z_\u00A1-\uFFFF][A-Za-z0-9_.\u00A1-\uFFFF]*$/.test(name) || /^[A-Za-z]{1,3}\d+$/.test(name) || /^(?:R\d*C?\d*|C\d*)$/i.test(name) || /^(?:TRUE|FALSE)$/i.test(name);
-function prefixText(prefix) {
-  const sheets = prefix.sheet2 !== void 0 ? `${prefix.sheet}:${prefix.sheet2}` : prefix.sheet;
-  const book = prefix.book !== void 0 ? `[${prefix.book}]` : "";
-  const quote = needsQuote(prefix.sheet) || prefix.sheet2 !== void 0 && needsQuote(prefix.sheet2);
-  return quote ? `'${(book + sheets).replace(/'/g, "''")}'!` : `${book}${sheets}!`;
+function shiftRef(ref, spec2) {
+  const isRow = spec2.axis === "row";
+  if (isRow && ref.kind === "cols" || !isRow && ref.kind === "rows") return ref;
+  const startFirst = isRow ? ref.start.row <= ref.end.row : ref.start.col <= ref.end.col;
+  const lo = startFirst ? ref.start : ref.end;
+  const hi = startFirst ? ref.end : ref.start;
+  const shifted2 = shiftInterval(
+    isRow ? lo.row : lo.col,
+    isRow ? hi.row : hi.col,
+    spec2.at,
+    spec2.count,
+    isRow ? MAX_ROW : MAX_COL
+  );
+  if (!shifted2) return void 0;
+  const [a, b] = shifted2;
+  const nlo = isRow ? { ...lo, row: a } : { ...lo, col: a };
+  const nhi = isRow ? { ...hi, row: b } : { ...hi, col: b };
+  const next = {
+    kind: ref.kind,
+    start: startFirst ? nlo : nhi,
+    end: startFirst ? nhi : nlo
+  };
+  if (ref.kind === "cell") next.end = next.start;
+  return sameSpec(next, ref) ? ref : next;
+}
+function shiftFormula(formula, formulaSheet, spec2) {
+  if (spec2.count === 0) return formula;
+  const sheet = spec2.sheet.toLowerCase();
+  const own = formulaSheet.toLowerCase() === sheet;
+  return rewriteTemplate(formula, (part) => {
+    if (part.kind !== "ref" || !part.ref || (part.prefix ? part.sheet !== sheet : !own))
+      return void 0;
+    const next = shiftRef(part.ref, spec2);
+    if (next === part.ref) return void 0;
+    const out = { kind: "ref", text: rewriteRef(part, next) };
+    if (part.prefix) out.prefix = part.prefix;
+    if (part.sheet !== void 0) out.sheet = part.sheet;
+    if (next) out.ref = next;
+    if (part.spill) out.spill = true;
+    return out;
+  });
 }
 function renameSheetInFormula(formula, oldName, newName) {
-  const tokens = safeTokens(formula);
-  if (!tokens) return formula;
   const lower2 = oldName.toLowerCase();
-  for (const token of tokens) {
-    const prefix = token.prefix;
-    if (!prefix || prefix.book !== void 0) continue;
-    const first2 = prefix.sheet.toLowerCase() === lower2;
+  return rewriteTemplate(formula, (part) => {
+    const prefix = part.prefix;
+    if (!prefix || part.sheet === void 0) return void 0;
+    const first2 = part.sheet === lower2;
     const second = prefix.sheet2?.toLowerCase() === lower2;
-    if (!first2 && !second) continue;
+    if (!first2 && !second) return void 0;
     const renamed = { ...prefix, sheet: first2 ? newName : prefix.sheet };
     if (prefix.sheet2 !== void 0) renamed.sheet2 = second ? newName : prefix.sheet2;
     const text2 = prefixText(renamed);
-    token.text = text2 + token.text.slice(prefix.text.length);
     renamed.text = text2;
-    token.prefix = renamed;
+    const out = { ...part, text: text2 + part.text.slice(prefix.text.length) };
+    out.prefix = renamed;
+    out.sheet = renamed.sheet.toLowerCase();
+    return out;
+  });
+}
+
+// xlsx/formula/transform.ts
+function translateFormula(formula, dRow, dCol) {
+  const tokens = safeTokens(formula);
+  if (!tokens) return formula;
+  for (const token of tokens) {
+    if (token.kind !== "ref" || !token.ref) continue;
+    const spec2 = token.ref;
+    const move = (c) => {
+      const row2 = spec2.kind === "cols" || c.rowAbs ? c.row : c.row + dRow;
+      const col = spec2.kind === "rows" || c.colAbs ? c.col : c.col + dCol;
+      if (row2 < 0 || row2 > MAX_ROW || col < 0 || col > MAX_COL) return void 0;
+      return { ...c, row: row2, col };
+    };
+    const start = move(spec2.start);
+    const end = move(spec2.end);
+    const next = start && end ? { kind: spec2.kind, start, end } : void 0;
+    if (next && sameSpec(next, spec2)) continue;
+    token.text = rewriteRef(token, next);
   }
   return joinTokens(tokens);
 }
@@ -13020,13 +13671,13 @@ function dataBarLengths(rule, node) {
     maxLength: rule.maxLength ?? numAttr(bar, "maxLength") ?? 90
   };
 }
-function rewriteConditionalExtension(rule, rewrite2) {
+function rewriteConditionalExtension(rule, rewrite) {
   if (!rule.extensionXml) return;
   const doc = parseXml(rule.extensionXml);
   let changed = false;
   for (const formula of descendants(doc.documentElement, "f", XM)) {
     const before = formula.textContent ?? "";
-    const next = rewrite2(before);
+    const next = rewrite(before);
     if (before !== next) {
       formula.textContent = next;
       changed = true;
@@ -14053,13 +14704,13 @@ function linearTrend(values2) {
   const slope = den ? num2 / den : 0;
   return (k) => Number((meanY + slope * (k - meanX)).toPrecision(15));
 }
-var isDigit4 = (ch) => ch !== void 0 && ch >= "0" && ch <= "9";
+var isDigit5 = (ch) => ch !== void 0 && ch >= "0" && ch <= "9";
 function matchTextNumber(text2) {
   let end = text2.length;
-  while (end > 0 && !isDigit4(text2[end - 1])) end--;
+  while (end > 0 && !isDigit5(text2[end - 1])) end--;
   if (end === 0) return null;
   let start = end;
-  while (start > 0 && isDigit4(text2[start - 1])) start--;
+  while (start > 0 && isDigit5(text2[start - 1])) start--;
   return [text2, text2.slice(0, start), text2.slice(start, end), text2.slice(end)];
 }
 var QUARTER = /^(q|qtr|quarter)(\s?)([1-4])$/i;
@@ -14242,10 +14893,10 @@ function removeValidationArea(rules, area) {
 }
 
 // xlsx/edit/conditional-formulas.ts
-function rewriteConditionalRule(rule, rewrite2) {
+function rewriteConditionalRule(rule, rewrite) {
   const safe2 = (formula) => {
     try {
-      return rewrite2(formula);
+      return rewrite(formula);
     } catch {
       return formula;
     }
@@ -14764,7 +15415,7 @@ function shiftPreservedXml(sheet, shift2, moveRange, banded) {
     (xml) => xml.includes("sqref")
   );
 }
-function rewritePreservedFormulas(sheet, rewrite2) {
+function rewritePreservedFormulas(sheet, rewrite) {
   editEntries(
     sheet,
     "extLst",
@@ -14774,7 +15425,7 @@ function rewritePreservedFormulas(sheet, rewrite2) {
         const text2 = f6.textContent ?? "";
         let next = text2;
         try {
-          next = rewrite2(text2, sheet.name);
+          next = rewrite(text2, sheet.name);
         } catch {
           next = text2;
         }
@@ -14789,46 +15440,46 @@ function rewritePreservedFormulas(sheet, rewrite2) {
 }
 
 // xlsx/edit/shift-formulas.ts
-function safe(rewrite2, formula, formulaSheet) {
+function safe(rewrite, formula, formulaSheet) {
   try {
-    return rewrite2(formula, formulaSheet);
+    return rewrite(formula, formulaSheet);
   } catch {
     return formula;
   }
 }
-function rewriteFormulas(workbook, rewrite2) {
-  for (const sheet of workbook.sheets) rewriteSheetFormulas(sheet, rewrite2);
+function rewriteFormulas(workbook, rewrite) {
+  for (const sheet of workbook.sheets) rewriteSheetFormulas(sheet, rewrite);
   for (const definedName of workbook.definedNames) {
     const local = definedName.localSheet === void 0 ? void 0 : workbook.sheets[definedName.localSheet];
-    definedName.formula = safe(rewrite2, definedName.formula, local?.name ?? "");
+    definedName.formula = safe(rewrite, definedName.formula, local?.name ?? "");
   }
 }
-function rewriteSheetFormulas(sheet, rewrite2) {
-  rewritePreservedFormulas(sheet, rewrite2);
+function rewriteSheetFormulas(sheet, rewrite) {
+  rewritePreservedFormulas(sheet, rewrite);
   {
     const name = sheet.name;
     for (const table2 of sheet.tables)
       for (const column of table2.columns)
         if (column.calculatedColumnFormula !== void 0)
-          column.calculatedColumnFormula = safe(rewrite2, column.calculatedColumnFormula, name);
+          column.calculatedColumnFormula = safe(rewrite, column.calculatedColumnFormula, name);
     for (const cells of sheet.rows.values())
       for (const cell of cells.values())
-        if (cell.formula !== void 0) cell.formula = safe(rewrite2, cell.formula, name);
+        if (cell.formula !== void 0) cell.formula = safe(rewrite, cell.formula, name);
     for (const cf of sheet.conditionalFormats)
-      for (const rule of cf.rules) rewriteConditionalRule(rule, (f6) => rewrite2(f6, name));
+      for (const rule of cf.rules) rewriteConditionalRule(rule, (f6) => rewrite(f6, name));
     for (const dv of sheet.dataValidations) {
-      if (dv.formula1 !== void 0) dv.formula1 = safe(rewrite2, dv.formula1, name);
-      if (dv.formula2 !== void 0) dv.formula2 = safe(rewrite2, dv.formula2, name);
+      if (dv.formula1 !== void 0) dv.formula1 = safe(rewrite, dv.formula1, name);
+      if (dv.formula2 !== void 0) dv.formula2 = safe(rewrite, dv.formula2, name);
     }
     for (const link of sheet.hyperlinks)
       if (link.location && /![A-Za-z$]/.test(link.location))
-        link.location = safe(rewrite2, link.location, name);
+        link.location = safe(rewrite, link.location, name);
     for (const drawing of sheet.drawings) {
       if (drawing.kind !== "chart") continue;
       for (const series of drawing.series) {
-        if (series.nameRef) series.nameRef = safe(rewrite2, series.nameRef, name);
-        if (series.categoriesRef) series.categoriesRef = safe(rewrite2, series.categoriesRef, name);
-        if (series.valuesRef) series.valuesRef = safe(rewrite2, series.valuesRef, name);
+        if (series.nameRef) series.nameRef = safe(rewrite, series.nameRef, name);
+        if (series.categoriesRef) series.categoriesRef = safe(rewrite, series.categoriesRef, name);
+        if (series.valuesRef) series.valuesRef = safe(rewrite, series.valuesRef, name);
       }
     }
   }
@@ -15015,7 +15666,7 @@ function shiftAxis(ctx, s, axis, at, count2, insert) {
       applyAxisShift(ctx, sheet, shift2);
       if (insert) inheritFormats(sheet, axis, at, count2);
     },
-    { sheet: s, structural: true }
+    { sheet: s, structural: true, calc: { kind: "shift", sheet: s, shift: shift2 } }
   );
 }
 var insertRows = (ctx, s, at, count2) => shiftAxis(ctx, s, "row", at, count2, true);
@@ -16829,6 +17480,14 @@ function setCalcMode(ctx, mode) {
 
 // xlsx/edit/session-calc.ts
 var isStructural = (step) => step.structural || step.entries.some((entry) => entry.before.kind !== "cells");
+function hintFor(step, mode) {
+  const hint = step.calc;
+  if (!hint) return void 0;
+  if (hint.kind === "rename")
+    return mode === "undo" ? { kind: "rename", from: hint.to, to: hint.from } : hint;
+  return mode === "undo" ? void 0 : hint;
+}
+var settingsOf = (workbook) => `${workbook.iterate ? `${workbook.iterate.count}:${workbook.iterate.delta}` : ""}|${workbook.date1904}`;
 var SessionCalculator = class {
   constructor(workbook, calc, enabled) {
     this.workbook = workbook;
@@ -16838,43 +17497,113 @@ var SessionCalculator = class {
   workbook;
   calc;
   enabled;
-  /** Structural edits made in manual mode leave the dependency graph stale until a full pass. */
+  /** Structural edits the engine could not follow leave the dependency graph stale (manual mode). */
   staleGraph = false;
+  /** Cells changed in manual mode since the last calculation. */
+  dirty = [];
+  /** The settings at the last calculation; undefined before the first. */
+  calculated;
   /** Recalculates after an applied, undone or redone step (failures become warnings). */
-  afterStep(step) {
-    if (!this.enabled) return;
+  afterStep(step, mode = "apply") {
+    if (!this.enabled) {
+      this.calc.discardPreparation();
+      return;
+    }
+    const structural = isStructural(step);
+    const hint = structural ? hintFor(step, mode) : void 0;
     if (calcModeOf(this.workbook) === "manual") {
-      if (isStructural(step)) this.staleGraph = true;
+      if (hint && !this.staleGraph && !this.dirty.length) {
+        this.guard(() => this.follow(hint));
+        return;
+      }
+      this.calc.discardPreparation();
+      if (structural) this.staleGraph = true;
+      else this.dirty.push(...touchedCells(step));
       return;
     }
-    this.recalc(isStructural(step), () => touchedCells(step));
+    if (hint && !this.staleGraph) {
+      this.guard(() => {
+        this.follow(hint);
+        this.calc.recalculateFrom(touchedCells(step));
+        this.calculated = settingsOf(this.workbook);
+      });
+      return;
+    }
+    this.recalc(structural, () => touchedCells(step));
   }
   /** Recalculates after a change applied outside the history (a collaborator's edit). */
   afterExternal(structural, cells) {
-    if (!this.enabled) return;
-    if (calcModeOf(this.workbook) === "manual") {
+    if (!this.enabled || calcModeOf(this.workbook) === "manual") {
+      this.calc.discardPreparation();
+      if (!this.enabled) return;
       if (structural) this.staleGraph = true;
+      else this.dirty.push(...cells);
       return;
     }
     this.recalc(structural, () => cells);
   }
-  recalc(structural, cells) {
+  follow(hint) {
+    if (hint.kind === "shift") this.calc.shiftCells(hint.sheet, hint.shift);
+    else this.calc.renameSheet(hint.from, hint.to);
+  }
+  guard(run) {
     try {
+      run();
+    } catch (error) {
+      const message = `Recalculation failed: ${error instanceof Error ? error.message : String(error)}`;
+      if (!this.workbook.warnings.includes(message)) this.workbook.warnings.push(message);
+    }
+  }
+  /** Builds the dependency graph ahead of the first edit (see `EditSession.prepareCalculation`). */
+  prepare(timeRemaining) {
+    if (!this.enabled || calcModeOf(this.workbook) === "manual" || this.staleGraph) return true;
+    try {
+      return this.calc.prepare(timeRemaining);
+    } catch {
+      this.calc.discardPreparation();
+      return true;
+    }
+  }
+  /**
+   * Before a structural edit the graph can follow in place: finishes a graph being prepared (or
+   * builds it) while it still matches the workbook, so the edit moves it instead of rebuilding.
+   */
+  beforeStructural() {
+    if (!this.enabled || calcModeOf(this.workbook) === "manual" || this.staleGraph) return;
+    this.prepare();
+  }
+  recalc(structural, cells) {
+    this.guard(() => {
       if (this.staleGraph || structural) this.full();
       else {
         const changed = cells();
         if (changed.length) this.calc.recalculateFrom(changed);
+        this.calculated = settingsOf(this.workbook);
       }
-    } catch (error) {
-      const message = `Recalculation failed: ${error instanceof Error ? error.message : String(error)}`;
-      if (!this.workbook.warnings.includes(message)) this.workbook.warnings.push(message);
-    }
+    });
   }
-  /** Rebuilds the dependency graph and recalculates every formula (F9). */
+  /** Rebuilds the dependency graph and recalculates every formula (Ctrl+Alt+F9). */
   full() {
     this.staleGraph = false;
+    this.dirty = [];
     this.calc.invalidate();
     this.calc.recalculateAll();
+    this.calculated = settingsOf(this.workbook);
+  }
+  /**
+   * Calculate Now (F9): the cells changed since the last calculation, the formulas structural
+   * edits queued, their dependents and the volatile functions. Everything when `full`, before
+   * the session's first calculation, after the iteration settings changed or while the graph
+   * is stale.
+   */
+  now(full) {
+    if (full || this.staleGraph || this.calculated !== settingsOf(this.workbook)) {
+      this.full();
+      return;
+    }
+    const changed = this.dirty;
+    this.dirty = [];
+    this.calc.recalculateFrom(changed);
   }
   /**
    * Recalculates one sheet's formulas and their dependents (Shift+F9); after structural edits
@@ -20383,12 +21112,12 @@ function renameSheet(ctx, index2, name) {
   ctx.run(
     "Rename sheet",
     "sheets",
-    [{ kind: "workbook" }],
+    [{ kind: "refs" }],
     () => {
       rewriteFormulas(workbook, (formula) => renameSheetInFormula(formula, old, name));
       sheet.name = name;
     },
-    { sheet: index2, structural: true }
+    { sheet: index2, structural: true, calc: { kind: "rename", from: old, to: name } }
   );
 }
 function moveSheet(ctx, from, to) {
@@ -20764,13 +21493,12 @@ function createEditSession(workbook, options = {}) {
     for (const listener of [...listeners2]) listener(change);
   };
   const calculator = new SessionCalculator(workbook, calc, autoRecalc);
-  const recalc = (step) => calculator.afterStep(step);
-  const begin = (label2, kind, info) => ({
-    step: { label: label2, entries: [], structural: info.structural ?? false },
-    kind,
-    sheet: info.sheet,
-    ranges: [...info.ranges ?? []]
-  });
+  const recalc = (step, mode = "apply") => calculator.afterStep(step, mode);
+  const begin = (label2, kind, info) => {
+    const step = { label: label2, entries: [], structural: info.structural ?? false };
+    if (info.calc) step.calc = info.calc;
+    return { step, kind, sheet: info.sheet, ranges: [...info.ranges ?? []] };
+  };
   const finish = (current) => {
     if (!current.step.entries.length) return;
     history.push(current.step);
@@ -20795,10 +21523,12 @@ function createEditSession(workbook, options = {}) {
     const outer = !open;
     const current = open ?? begin(label2, kind, info);
     if (!outer) {
+      delete current.step.calc;
       if (info.structural) current.step.structural = true;
       if (current.sheet === void 0 && info.sheet !== void 0) current.sheet = info.sheet;
       current.ranges.push(...info.ranges ?? []);
     }
+    if (outer && info.calc) calculator.beforeStructural();
     open = current;
     const mark = current.step.entries.length;
     const befores = scopes.map((scope) => captureScope(workbook, scope));
@@ -20846,7 +21576,7 @@ function createEditSession(workbook, options = {}) {
     if (open) throw new Error(`Cannot ${kind} inside a batch`);
     const step = kind === "undo" ? history.undo(workbook) : history.redo(workbook);
     if (!step) return false;
-    recalc(step);
+    recalc(step, kind);
     emit({ kind, label: step.label, structural: step.structural });
     return true;
   };
@@ -20925,10 +21655,11 @@ function createEditSession(workbook, options = {}) {
     setDocumentProperties: (patch) => setDocumentProperties(ctx, patch),
     setAutoRecalc: (enabled) => setCalcMode(ctx, enabled ? "auto" : "manual"),
     autoRecalc: () => autoRecalc && calcModeOf(workbook) === "auto",
-    calculateNow() {
-      calculator.full();
+    calculateNow(options2) {
+      calculator.now(options2?.full ?? false);
       emit({ kind: "cells", label: "Calculate now", structural: false });
     },
+    prepareCalculation: (opts) => calculator.prepare(opts?.timeRemaining),
     calculateSheet(s) {
       calculator.sheet(s);
       emit({ kind: "cells", label: "Calculate sheet", sheet: s, structural: false });