ooxml-core 1.2.0 → 1.2.1

package/dist/xlsx/index.cjs

@@ -2108,7 +2108,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);
@@ -2480,7 +2480,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 tokens2 = [];
   const wsBefore = [];
   let sawWs = false;
@@ -2765,6 +2767,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, value) {
+  const list = map.get(key);
+  if (list) list.push(value);
+  else map.set(key, [value]);
+}
+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 entry3 = { range: area.range, node };
+    if (end.col - start.col + 1 > BUCKET_WIDTH) {
+      const list = this.wide.get(area.sheet);
+      if (list) list.push(entry3);
+      else this.wide.set(area.sheet, [entry3]);
+      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 c2 = start.col; c2 <= end.col; c2++) push(cols2, c2, entry3);
+      return;
+    }
+    const cols = inner(this.chunked, area.sheet);
+    for (let c2 = start.col; c2 <= end.col; c2++) {
+      let chunks = cols.get(c2);
+      if (!chunks) cols.set(c2, chunks = /* @__PURE__ */ new Map());
+      for (let k = first2; k <= last; k++) push(chunks, k, entry3);
+    }
+  }
+  /** Items whose areas intersect `range` on `sheet` (each once). */
+  dependents(sheet, range, out) {
+    const found = out instanceof Set ? out : /* @__PURE__ */ new Set();
+    this.collect(sheet, range, found);
+    if (Array.isArray(out)) for (const node of found) out.push(node);
+  }
+  collect(sheet, range, out) {
+    const { start, end } = range;
+    const check3 = (list) => {
+      if (list) {
+        for (const entry3 of list) if (rangesIntersect(entry3.range, range)) out.add(entry3.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 c2 = start.col; c2 <= end.col; c2++) {
+            const list = cells.get(cellKey(r, c2));
+            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 c2 = start.col; c2 <= end.col; c2++) if (map.has(c2)) visit2(c2);
+      } else for (const c2 of map.keys()) if (c2 >= start.col && c2 <= end.col) visit2(c2);
+    };
+    const chunked = this.chunked.get(sheet);
+    const first2 = start.row >> CHUNK_SHIFT;
+    const last = end.row >> CHUNK_SHIFT;
+    columns(chunked, (c2) => {
+      const chunks = chunked?.get(c2);
+      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, (c2) => check3(tall?.get(c2)));
+    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((a2, b) => a2.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 scan4 = (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 c2 = start.col; c2 <= end.col; c2++) {
+        const list = cols.get(c2);
+        if (list) scan4(list);
+      }
+    } else {
+      for (const [c2, list] of cols) if (c2 >= start.col && c2 <= end.col) scan4(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",
@@ -5899,8 +6117,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];
@@ -7470,9 +7690,9 @@ function readBlock(ctx, area, rows, cols) {
   if (host.readBlock) return host.readBlock(area.sheet, range);
   return Matrix.build(rows, cols, (r, c2) => ctx.readCell(area.sheet, row2 + r, col + c2));
 }
-function shapedMatrices(ctx, values2, sameShape) {
+function shapedMatrices(ctx, values2, sameShape2) {
   let { rows, cols } = shapeOf(values2[0] ?? null);
-  if (sameShape) {
+  if (sameShape2) {
     for (const value of values2) {
       const shape2 = shapeOf(value);
       if (shape2.rows !== rows || shape2.cols !== cols) fail(ERR.VALUE);
@@ -7498,12 +7718,12 @@ function shapedMatrices(ctx, values2, sameShape) {
   });
   return { matrices, total: total2, block: rows * cols };
 }
-function matchingCells(ctx, pairs, target, sameShape) {
+function matchingCells(ctx, pairs, target, sameShape2) {
   const ranges = pairs.map((p) => p.range);
   const { matrices, total: total2, block } = shapedMatrices(
     ctx,
     target === void 0 ? ranges : [...ranges, target],
-    sameShape
+    sameShape2
   );
   const tests = pairs.map((p) => makeCriteria(scalar(p.criteria)));
   const values2 = matrices[matrices.length - 1];
@@ -7542,7 +7762,7 @@ function indexedCandidates(pairs, matrices) {
   }
   return void 0;
 }
-var matchingValues = (ctx, pairs, target, sameShape) => matchingCells(ctx, pairs, target, sameShape).values;
+var matchingValues = (ctx, pairs, target, sameShape2) => matchingCells(ctx, pairs, target, sameShape2).values;
 function criteriaPairs(args, from) {
   if ((args.length - from) % 2 !== 0) fail(ERR.VALUE);
   const pairs = [];
@@ -11436,7 +11656,7 @@ var REFERENCE_ARGUMENT = /* @__PURE__ */ new Set([
   "AREAS",
   "ISREF"
 ]);
-var push = (c2, area) => {
+var push2 = (c2, area) => {
   (c2.dynamic > 0 ? c2.dynamicDeps : c2.deps).push(area);
 };
 function spans(areas) {
@@ -11462,7 +11682,7 @@ function visit(node, c2) {
       if (!sheets) return;
       const range = specRange(node.ref);
       const target = node.spill ? { start: range.start, end: { ...range.start } } : range;
-      for (const sheet of sheets) push(c2, { sheet, range: target });
+      for (const sheet of sheets) push2(c2, { sheet, range: target });
       return;
     }
     case "name": {
@@ -11536,7 +11756,7 @@ function visitBinary(node, c2) {
       const list = c2.dynamic > 0 ? c2.dynamicDeps : c2.deps;
       const l = list[list.length - 2];
       const r = list[list.length - 1];
-      if (l && r && l.sheet === r.sheet) push(c2, spans([l, r])[0]);
+      if (l && r && l.sheet === r.sheet) push2(c2, spans([l, r])[0]);
       continue;
     }
     const mentioned = [...c2.deps.slice(staticStart), ...c2.dynamicDeps.slice(dynamicStart)];
@@ -11552,7 +11772,7 @@ function addStructured(ref, c2) {
     sheet: c2.sheet,
     row: c2.row,
     col: c2.col});
-  if (value instanceof RefValue) for (const area of value.areas) push(c2, area);
+  if (value instanceof RefValue) for (const area of value.areas) push2(c2, area);
 }
 function analyze(ast, host, sheet, row2, col) {
   const c2 = {
@@ -11576,155 +11796,191 @@ 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, value) {
-  const list = map.get(key);
-  if (list) list.push(value);
-  else map.set(key, [value]);
+// 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(a2, from, b, at, length) {
+  for (let k = 0; k < length; k++)
+    if (a2.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(a2, 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] : a2.length;
+    const toB = i2 < runs ? bs.starts[i2] : b.length;
+    if (toA - fromA !== toB - fromB || !sameText(a2, fromA, b, fromB, toA - fromA)) return false;
+    fromA = as.ends[i2] ?? 0;
+    fromB = bs.ends[i2] ?? 0;
+  }
+  return true;
+}
+function makeTemplate(formula, shape2) {
+  let tokens2;
+  let ast;
+  try {
+    tokens2 = tokenize(formula);
+    ast = parseTokens(tokens2);
+  } 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 run2 = 0;
+  for (const token of tokens2) {
+    const end = token.start + token.text.length;
+    const first2 = run2;
+    while (run2 < starts.length && starts[run2] < end) run2++;
+    const ref = token.kind === "ref" ? token.ref : void 0;
+    if (!ref || ref.kind === "cols") continue;
+    const count2 = ref.kind === "cell" ? 1 : 2;
+    if (run2 - first2 < count2) continue;
+    const at = run2 - 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 rows = [];
+  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;
+      rows.push(-1);
+      continue;
     }
-    const entry3 = { range: area.range, node };
-    if (end.col - start.col + 1 > BUCKET_WIDTH) {
-      const list = this.wide.get(area.sheet);
-      if (list) list.push(entry3);
-      else this.wide.set(area.sheet, [entry3]);
-      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;
+    rows.push(row2 - 1);
+  }
+  return rows;
+}
+function shiftSpec(spec2, slots, rows) {
+  const startRow = rows[slots.start];
+  const endRow = slots.end === void 0 ? startRow : rows[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, rows) {
+  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, rows);
+      if (ref === node.ref) return node;
+      const copy = { type: "ref" };
+      if (node.prefix) copy.prefix = node.prefix;
+      copy.ref = ref;
+      if (node.spill) copy.spill = true;
+      return copy;
     }
-    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 c2 = start.col; c2 <= end.col; c2++) push2(cols2, c2, entry3);
-      return;
+    case "unary":
+    case "percent": {
+      const operand4 = copyTree(node.operand, t, rows);
+      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 c2 = start.col; c2 <= end.col; c2++) {
-      let chunks = cols.get(c2);
-      if (!chunks) cols.set(c2, chunks = /* @__PURE__ */ new Map());
-      for (let k = first2; k <= last; k++) push2(chunks, k, entry3);
+    case "binary": {
+      const left2 = copyTree(node.left, t, rows);
+      const right2 = copyTree(node.right, t, rows);
+      if (left2 === node.left && right2 === node.right) return node;
+      return { type: "binary", op: node.op, left: left2, right: right2 };
     }
-  }
-  /** Items whose areas intersect `range` on `sheet` (each once). */
-  dependents(sheet, range, out) {
-    const found = out instanceof Set ? out : /* @__PURE__ */ new Set();
-    this.collect(sheet, range, found);
-    if (Array.isArray(out)) for (const node of found) out.push(node);
-  }
-  collect(sheet, range, out) {
-    const { start, end } = range;
-    const check3 = (list) => {
-      if (list) {
-        for (const entry3 of list) if (rangesIntersect(entry3.range, range)) out.add(entry3.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 c2 = start.col; c2 <= end.col; c2++) {
-            const list = cells.get(cellKey(r, c2));
-            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);
-        }
-      }
+    case "call": {
+      const args = copyAll(node.args, t, rows);
+      if (args === node.args) return node;
+      return { type: "call", name: node.name, rawName: node.rawName, args };
     }
-    const columns = (map, visit2) => {
-      if (!map) return;
-      if (end.col - start.col + 1 <= map.size) {
-        for (let c2 = start.col; c2 <= end.col; c2++) if (map.has(c2)) visit2(c2);
-      } else for (const c2 of map.keys()) if (c2 >= start.col && c2 <= end.col) visit2(c2);
-    };
-    const chunked = this.chunked.get(sheet);
-    const first2 = start.row >> CHUNK_SHIFT;
-    const last = end.row >> CHUNK_SHIFT;
-    columns(chunked, (c2) => {
-      const chunks = chunked?.get(c2);
-      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, (c2) => check3(tall?.get(c2)));
-    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);
+    case "invoke": {
+      const callee = copyTree(node.callee, t, rows);
+      const args = copyAll(node.args, t, rows);
+      if (callee === node.callee && args === node.args) return node;
+      return { type: "invoke", callee, args };
     }
-    for (const cols of this.sheets.values())
-      for (const list of cols.values()) list.sort((a2, b) => a2.row - b.row);
+    default:
+      return node;
   }
-  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 scan4 = (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 c2 = start.col; c2 <= end.col; c2++) {
-        const list = cols.get(c2);
-        if (list) scan4(list);
-      }
-    } else {
-      for (const [c2, list] of cols) if (c2 >= start.col && c2 <= end.col) scan4(list);
-    }
+}
+function copyAll(nodes, t, rows) {
+  let out;
+  for (let i2 = 0; i2 < nodes.length; i2++) {
+    const node = nodes[i2];
+    const copy = copyTree(node, t, rows);
+    if (copy !== node && !out) out = nodes.slice(0, i2);
+    out?.push(copy);
+  }
+  return out ?? nodes;
+}
+function fromTemplate(t, formula, shape2) {
+  const rows = rowsFor(t, formula, shape2);
+  return rows ? copyTree(t.ast, t, rows) : 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;
   }
-};
-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);
+  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);
   }
 };
 
@@ -11865,7 +12121,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();
@@ -11889,6 +12145,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);
@@ -11977,41 +12235,15 @@ 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();
   }
-  random() {
-    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();
-  }
+  random() {
+    return this.options.random ? this.options.random() : Math.random();
+  }
+  // ---- graph ----
   createNode(sheet, row2, col, cell, initial) {
     const formula = cell.formula ?? "";
     const parsed = this.parse(formula);
@@ -12040,6 +12272,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) {
@@ -12470,6 +12710,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);
@@ -12487,20 +12728,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(a2, b, shift2) {
+  const { at, count: count2 } = shift2;
+  if (count2 > 0) {
+    if (b < at) return 0;
+    if (a2 < 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 (a2 > 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(range, axis, delta) {
+  if (delta === 0) return range;
+  return axis === "row" ? {
+    start: { row: range.start.row + delta, col: range.start.col },
+    end: { row: range.end.row + delta, col: range.end.col }
+  } : {
+    start: { row: range.start.row, col: range.start.col + delta },
+    end: { row: range.end.row, col: range.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 a2 = axis === "row" ? start.row : start.col;
+  const b = axis === "row" ? end.row : end.col;
+  if (a2 === b) return false;
+  return pos >= a2 && pos <= b || pos + nodeDelta >= a2 + delta && pos + nodeDelta <= b + delta;
+}
+
+// xlsx/formula/engine-structure.ts
+var sameAreas = (a2, b) => a2.length === b.length && a2.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 target = 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(target)) {
+          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;
@@ -12544,6 +13128,7 @@ var Engine = class extends EngineCore {
       }
     }
     if (structural) this.graphChanged();
+    this.takeStructuralSeeds(seeds);
     const reverse2 = this.reverse();
     for (const area of changed) reverse2.dependents(area.sheet, area.range, seeds);
     for (const node of this.allNodes()) if (node.volatile) seeds.add(node);
@@ -12555,13 +13140,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((c2) => `${c2.sheet}:${cellKey(c2.row, c2.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;
   }
@@ -12575,7 +13165,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();
@@ -12620,7 +13213,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);
@@ -12639,50 +13232,26 @@ function formatRefSpec(spec2) {
   if (spec2.kind === "cell") return a2;
   return `${a2}:${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 = (a2, b) => a2.kind === b.kind && a2.start.row === b.start.row && a2.start.col === b.start.col && a2.end.row === b.end.row && a2.end.col === b.end.col;
-function translateFormula(formula, dRow, dCol) {
-  const tokens2 = safeTokens(formula);
-  if (!tokens2) return formula;
-  for (const token of tokens2) {
-    if (token.kind !== "ref" || !token.ref) continue;
-    const spec2 = token.ref;
-    const move = (c2) => {
-      const row2 = spec2.kind === "cols" || c2.rowAbs ? c2.row : c2.row + dRow;
-      const col = spec2.kind === "rows" || c2.colAbs ? c2.col : c2.col + dCol;
-      if (row2 < 0 || row2 > MAX_ROW || col < 0 || col > MAX_COL) return void 0;
-      return { ...c2, 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(tokens2);
+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 quote2 = needsQuote(prefix.sheet) || prefix.sheet2 !== void 0 && needsQuote(prefix.sheet2);
+  return quote2 ? `'${(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(a2, b, at, count2, max) {
-  if (count2 > 0) {
-    const na2 = a2 >= at ? a2 + count2 : a2;
-    const nb2 = b >= at ? b + count2 : b;
-    if (nb2 > max) return na2 > max ? void 0 : [na2, max];
-    return [na2, nb2];
-  }
-  const n2 = -count2;
-  const last = at + n2 - 1;
-  if (a2 >= at && b <= last) return void 0;
-  const na = a2 < at ? a2 : a2 <= last ? at : a2 - n2;
-  const nb = b < at ? b : b <= last ? at - 1 : b - n2;
-  return [na, nb];
+
+// xlsx/formula/shift-formula.ts
+var templates = /* @__PURE__ */ new Map();
+var MAX_TEMPLATES2 = 2e5;
+function remember(text3, template) {
+  if (templates.size >= MAX_TEMPLATES2) templates.clear();
+  templates.set(text3, template);
 }
 function mergeSpacedAreas(tokens2) {
   const out = [];
@@ -12709,63 +13278,145 @@ function mergeSpacedAreas(tokens2) {
   }
   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 raw2 = safeTokens(formula);
-  if (!raw2) return formula;
-  const tokens2 = mergeSpacedAreas(raw2);
-  const isRow = spec2.axis === "row";
-  for (const token of tokens2) {
-    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 [a2, b] = shifted2;
-      const nlo = isRow ? { ...lo, row: a2 } : { ...lo, col: a2 };
-      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;
+  let template = null;
+  if (raw2) {
+    template = [];
+    let literal2 = "";
+    for (const token of mergeSpacedAreas(raw2)) {
+      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 (next && sameSpec(next, ref)) continue;
-    token.text = rewrite(token, next);
+    if (literal2) template.push(literal2);
   }
-  return joinTokens(tokens2);
+  remember(formula, template);
+  return template;
 }
-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 quote2 = needsQuote(prefix.sheet) || prefix.sheet2 !== void 0 && needsQuote(prefix.sheet2);
-  return quote2 ? `'${(book + sheets).replace(/'/g, "''")}'!` : `${book}${sheets}!`;
+function rewriteTemplate(formula, rewrite2) {
+  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 = rewrite2(part);
+    if (!changed) continue;
+    next ??= template.slice();
+    next[i2] = changed;
+  }
+  if (!next) return formula;
+  const text3 = next.map((part) => typeof part === "string" ? part : part.text).join("");
+  remember(text3, next);
+  return text3;
+}
+function shiftInterval(a2, b, at, count2, max) {
+  if (count2 > 0) {
+    const na2 = a2 >= at ? a2 + count2 : a2;
+    const nb2 = b >= at ? b + count2 : b;
+    if (nb2 > max) return na2 > max ? void 0 : [na2, max];
+    return [na2, nb2];
+  }
+  const n2 = -count2;
+  const last = at + n2 - 1;
+  if (a2 >= at && b <= last) return void 0;
+  const na = a2 < at ? a2 : a2 <= last ? at : a2 - n2;
+  const nb = b < at ? b : b <= last ? at - 1 : b - n2;
+  return [na, nb];
+}
+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 [a2, b] = shifted2;
+  const nlo = isRow ? { ...lo, row: a2 } : { ...lo, col: a2 };
+  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 tokens2 = safeTokens(formula);
-  if (!tokens2) return formula;
   const lower2 = oldName.toLowerCase();
-  for (const token of tokens2) {
-    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 text3 = prefixText(renamed);
-    token.text = text3 + token.text.slice(prefix.text.length);
     renamed.text = text3;
-    token.prefix = renamed;
+    const out = { ...part, text: text3 + 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 tokens2 = safeTokens(formula);
+  if (!tokens2) return formula;
+  for (const token of tokens2) {
+    if (token.kind !== "ref" || !token.ref) continue;
+    const spec2 = token.ref;
+    const move = (c2) => {
+      const row2 = spec2.kind === "cols" || c2.rowAbs ? c2.row : c2.row + dRow;
+      const col = spec2.kind === "rows" || c2.colAbs ? c2.col : c2.col + dCol;
+      if (row2 < 0 || row2 > MAX_ROW || col < 0 || col > MAX_COL) return void 0;
+      return { ...c2, 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(tokens2);
 }
@@ -15592,7 +16243,7 @@ var FUTURE_FUNCTIONS = new Set(
   "AGGREGATE BETA.DIST BETA.INV BINOM.DIST BINOM.INV CEILING.PRECISE CHISQ.DIST CHISQ.DIST.RT CHISQ.INV CHISQ.INV.RT CHISQ.TEST CONFIDENCE.NORM CONFIDENCE.T COVARIANCE.P COVARIANCE.S ERF.PRECISE ERFC.PRECISE EXPON.DIST F.DIST F.DIST.RT F.INV F.INV.RT F.TEST FLOOR.PRECISE GAMMA.DIST GAMMA.INV GAMMALN.PRECISE HYPGEOM.DIST LOGNORM.DIST LOGNORM.INV MODE.MULT MODE.SNGL NEGBINOM.DIST NETWORKDAYS.INTL NORM.DIST NORM.INV NORM.S.DIST NORM.S.INV PERCENTILE.EXC PERCENTILE.INC PERCENTRANK.EXC PERCENTRANK.INC POISSON.DIST QUARTILE.EXC QUARTILE.INC RANK.AVG RANK.EQ STDEV.P STDEV.S T.DIST T.DIST.2T T.DIST.RT T.INV T.INV.2T T.TEST VAR.P VAR.S WEIBULL.DIST WORKDAY.INTL ACOT ACOTH ARABIC BASE BINOM.DIST.RANGE BITAND BITLSHIFT BITOR BITRSHIFT BITXOR CEILING.MATH COMBINA COT COTH CSC CSCH DAYS DECIMAL ENCODEURL FILTERXML FLOOR.MATH FORMULATEXT GAMMA GAUSS IFNA IMCOSH IMCOT IMCSC IMCSCH IMSEC IMSECH IMSINH IMTAN ISFORMULA ISOWEEKNUM MUNIT NUMBERVALUE PDURATION PERMUTATIONA PHI RRI SEC SECH SHEET SHEETS SKEW.P UNICHAR UNICODE WEBSERVICE XOR CONCAT FORECAST.ETS FORECAST.ETS.CONFINT FORECAST.ETS.SEASONALITY FORECAST.ETS.STAT FORECAST.LINEAR IFS MAXIFS MINIFS SWITCH TEXTJOIN XLOOKUP XMATCH FILTER SORT SORTBY UNIQUE SEQUENCE RANDARRAY LET LAMBDA TEXTBEFORE TEXTAFTER TEXTSPLIT VSTACK HSTACK TAKE DROP CHOOSEROWS CHOOSECOLS TOCOL TOROW WRAPROWS WRAPCOLS EXPAND ARRAYTOTEXT VALUETOTEXT ISOMITTED BYROW BYCOL MAP REDUCE SCAN MAKEARRAY IMAGE GROUPBY PIVOTBY PERCENTOF REGEXTEST REGEXEXTRACT REGEXREPLACE TRIMRANGE ANCHORARRAY SINGLE STOCKHISTORY FIELDVALUE".split(" ")
 );
 var WORKSHEET_PREFIXED = /* @__PURE__ */ new Set(["FILTER", "SORT"]);
-function rewrite2(formula, visit2) {
+function rewrite(formula, visit2) {
   const out = [];
   let i2 = 0;
   while (i2 < formula.length) {
@@ -15635,7 +16286,7 @@ function rewrite2(formula, visit2) {
 }
 function stripFuturePrefixes(formula) {
   if (!formula.includes("_xl")) return formula;
-  const plain2 = rewrite2(formula, (token, next, out) => {
+  const plain2 = rewrite(formula, (token, next, out) => {
     if (!next.startsWith("(")) return false;
     const stripped = token.replace(/^(_xlfn\.)?(_xlws\.)?/i, "");
     if (stripped === token) return false;
@@ -15645,7 +16296,7 @@ function stripFuturePrefixes(formula) {
   return fromStoredSyntax(plain2);
 }
 function addFuturePrefixes(formula) {
-  return rewrite2(toStoredSyntax(formula), (token, next, out) => {
+  return rewrite(toStoredSyntax(formula), (token, next, out) => {
     if (!next.startsWith("(")) return false;
     const upper2 = token.toUpperCase();
     if (!FUTURE_FUNCTIONS.has(upper2)) return false;
@@ -17727,13 +18378,13 @@ function dataBarLengths(rule, node) {
     maxLength: rule.maxLength ?? numAttr(bar, "maxLength") ?? 90
   };
 }
-function rewriteConditionalExtension(rule, rewrite3) {
+function rewriteConditionalExtension(rule, rewrite2) {
   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 = rewrite3(before);
+    const next = rewrite2(before);
     if (before !== next) {
       formula.textContent = next;
       changed = true;
@@ -19876,6 +20527,7 @@ Reply:
 }
 
 // chart/bar-cluster-geometry.ts
+var DEFAULT_BAR_GAP_WIDTH = 150;
 function assertBarClusterOptions(options) {
   for (const [field, min, max] of [
     ["barGapWidth", 0, 500],
@@ -19889,7 +20541,8 @@ function assertBarClusterOptions(options) {
 function clusteredBarGeometry(barGroupWidth, seriesCount, chartData) {
   const overlap = chartData.barOverlap ?? 0;
   const overlapSpan = 1 + (seriesCount - 1) * (1 - overlap / 100);
-  const singleBarWidth = chartData.barGapWidth !== void 0 ? barGroupWidth / (overlapSpan + Math.max(chartData.barGapWidth, 0) / 100) : barGroupWidth * 0.7 / seriesCount;
+  const gapWidth = chartData.barGapWidth ?? DEFAULT_BAR_GAP_WIDTH;
+  const singleBarWidth = barGroupWidth / (overlapSpan + Math.max(gapWidth, 0) / 100);
   const step2 = singleBarWidth * (1 - overlap / 100);
   return { singleBarWidth, step: step2, clusterWidth: singleBarWidth + step2 * (seriesCount - 1) };
 }
@@ -24381,13 +25034,13 @@ function linearTrend(values2) {
   const slope = den ? num3 / 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(text3) {
   let end = text3.length;
-  while (end > 0 && !isDigit4(text3[end - 1])) end--;
+  while (end > 0 && !isDigit5(text3[end - 1])) end--;
   if (end === 0) return null;
   let start = end;
-  while (start > 0 && isDigit4(text3[start - 1])) start--;
+  while (start > 0 && isDigit5(text3[start - 1])) start--;
   return [text3, text3.slice(0, start), text3.slice(start, end), text3.slice(end)];
 }
 var QUARTER = /^(q|qtr|quarter)(\s?)([1-4])$/i;
@@ -24570,10 +25223,10 @@ function removeValidationArea(rules, area) {
 }
 
 // xlsx/edit/conditional-formulas.ts
-function rewriteConditionalRule(rule, rewrite3) {
+function rewriteConditionalRule(rule, rewrite2) {
   const safe2 = (formula) => {
     try {
-      return rewrite3(formula);
+      return rewrite2(formula);
     } catch {
       return formula;
     }
@@ -25092,7 +25745,7 @@ function shiftPreservedXml(sheet, shift2, moveRange, banded) {
     (xml) => xml.includes("sqref")
   );
 }
-function rewritePreservedFormulas(sheet, rewrite3) {
+function rewritePreservedFormulas(sheet, rewrite2) {
   editEntries(
     sheet,
     "extLst",
@@ -25102,7 +25755,7 @@ function rewritePreservedFormulas(sheet, rewrite3) {
         const text3 = f6.textContent ?? "";
         let next = text3;
         try {
-          next = rewrite3(text3, sheet.name);
+          next = rewrite2(text3, sheet.name);
         } catch {
           next = text3;
         }
@@ -25117,46 +25770,46 @@ function rewritePreservedFormulas(sheet, rewrite3) {
 }
 
 // xlsx/edit/shift-formulas.ts
-function safe(rewrite3, formula, formulaSheet) {
+function safe(rewrite2, formula, formulaSheet) {
   try {
-    return rewrite3(formula, formulaSheet);
+    return rewrite2(formula, formulaSheet);
   } catch {
     return formula;
   }
 }
-function rewriteFormulas(workbook, rewrite3) {
-  for (const sheet of workbook.sheets) rewriteSheetFormulas(sheet, rewrite3);
+function rewriteFormulas(workbook, rewrite2) {
+  for (const sheet of workbook.sheets) rewriteSheetFormulas(sheet, rewrite2);
   for (const definedName of workbook.definedNames) {
     const local = definedName.localSheet === void 0 ? void 0 : workbook.sheets[definedName.localSheet];
-    definedName.formula = safe(rewrite3, definedName.formula, local?.name ?? "");
+    definedName.formula = safe(rewrite2, definedName.formula, local?.name ?? "");
   }
 }
-function rewriteSheetFormulas(sheet, rewrite3) {
-  rewritePreservedFormulas(sheet, rewrite3);
+function rewriteSheetFormulas(sheet, rewrite2) {
+  rewritePreservedFormulas(sheet, rewrite2);
   {
     const name = sheet.name;
     for (const table2 of sheet.tables)
       for (const column of table2.columns)
         if (column.calculatedColumnFormula !== void 0)
-          column.calculatedColumnFormula = safe(rewrite3, column.calculatedColumnFormula, name);
+          column.calculatedColumnFormula = safe(rewrite2, column.calculatedColumnFormula, name);
     for (const cells of sheet.rows.values())
       for (const cell of cells.values())
-        if (cell.formula !== void 0) cell.formula = safe(rewrite3, cell.formula, name);
+        if (cell.formula !== void 0) cell.formula = safe(rewrite2, cell.formula, name);
     for (const cf of sheet.conditionalFormats)
-      for (const rule of cf.rules) rewriteConditionalRule(rule, (f6) => rewrite3(f6, name));
+      for (const rule of cf.rules) rewriteConditionalRule(rule, (f6) => rewrite2(f6, name));
     for (const dv of sheet.dataValidations) {
-      if (dv.formula1 !== void 0) dv.formula1 = safe(rewrite3, dv.formula1, name);
-      if (dv.formula2 !== void 0) dv.formula2 = safe(rewrite3, dv.formula2, name);
+      if (dv.formula1 !== void 0) dv.formula1 = safe(rewrite2, dv.formula1, name);
+      if (dv.formula2 !== void 0) dv.formula2 = safe(rewrite2, dv.formula2, name);
     }
     for (const link of sheet.hyperlinks)
       if (link.location && /![A-Za-z$]/.test(link.location))
-        link.location = safe(rewrite3, link.location, name);
+        link.location = safe(rewrite2, 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(rewrite3, series.nameRef, name);
-        if (series.categoriesRef) series.categoriesRef = safe(rewrite3, series.categoriesRef, name);
-        if (series.valuesRef) series.valuesRef = safe(rewrite3, series.valuesRef, name);
+        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);
       }
     }
   }
@@ -25343,7 +25996,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);
@@ -27161,6 +27814,14 @@ function setCalcMode(ctx, mode) {
 
 // xlsx/edit/session-calc.ts
 var isStructural = (step2) => step2.structural || step2.entries.some((entry3) => entry3.before.kind !== "cells");
+function hintFor(step2, mode) {
+  const hint = step2.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;
@@ -27170,43 +27831,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(step2) {
-    if (!this.enabled) return;
+  afterStep(step2, mode = "apply") {
+    if (!this.enabled) {
+      this.calc.discardPreparation();
+      return;
+    }
+    const structural = isStructural(step2);
+    const hint = structural ? hintFor(step2, mode) : void 0;
     if (calcModeOf(this.workbook) === "manual") {
-      if (isStructural(step2)) 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(step2));
+      return;
+    }
+    if (hint && !this.staleGraph) {
+      this.guard(() => {
+        this.follow(hint);
+        this.calc.recalculateFrom(touchedCells(step2));
+        this.calculated = settingsOf(this.workbook);
+      });
       return;
     }
-    this.recalc(isStructural(step2), () => touchedCells(step2));
+    this.recalc(structural, () => touchedCells(step2));
   }
   /** 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(run2) {
+    try {
+      run2();
+    } 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
@@ -30977,12 +31708,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) {
@@ -31372,13 +32103,12 @@ function createEditSession(workbook, options = {}) {
     for (const listener of [...listeners]) listener(change);
   };
   const calculator = new SessionCalculator(workbook, calc, autoRecalc);
-  const recalc = (step2) => calculator.afterStep(step2);
-  const begin = (label2, kind, info) => ({
-    step: { label: label2, entries: [], structural: info.structural ?? false },
-    kind,
-    sheet: info.sheet,
-    ranges: [...info.ranges ?? []]
-  });
+  const recalc = (step2, mode = "apply") => calculator.afterStep(step2, mode);
+  const begin = (label2, kind, info) => {
+    const step2 = { label: label2, entries: [], structural: info.structural ?? false };
+    if (info.calc) step2.calc = info.calc;
+    return { step: step2, kind, sheet: info.sheet, ranges: [...info.ranges ?? []] };
+  };
   const finish = (current) => {
     if (!current.step.entries.length) return;
     history.push(current.step);
@@ -31403,10 +32133,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));
@@ -31454,7 +32186,7 @@ function createEditSession(workbook, options = {}) {
     if (open) throw new Error(`Cannot ${kind} inside a batch`);
     const step2 = kind === "undo" ? history.undo(workbook) : history.redo(workbook);
     if (!step2) return false;
-    recalc(step2);
+    recalc(step2, kind);
     emit({ kind, label: step2.label, structural: step2.structural });
     return true;
   };
@@ -31533,10 +32265,11 @@ function createEditSession(workbook, options = {}) {
     setDocumentProperties: (patch2) => setDocumentProperties(ctx, patch2),
     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 });
@@ -32191,6 +32924,7 @@ function selectionStats(workbook, sheet, ranges) {
   const seen = /* @__PURE__ */ new Set();
   let min = Infinity;
   let max = -Infinity;
+  let numFmt;
   for (const range of ranges)
     forEachCellInRange(ws, range, (cell, row2, col) => {
       if (ranges.length > 1) {
@@ -32203,6 +32937,7 @@ function selectionStats(workbook, sheet, ranges) {
       out.count++;
       if (typeof value === "number" && Number.isFinite(value)) {
         out.numericCount++;
+        numFmt ??= styleAt(workbook, effectiveStyleId(ws, row2, col)).numFmt || "General";
         out.sum += value;
         min = Math.min(min, value);
         max = Math.max(max, value);
@@ -32212,9 +32947,13 @@ function selectionStats(workbook, sheet, ranges) {
     out.average = out.sum / out.numericCount;
     out.min = min;
     out.max = max;
+    out.numFmt = numFmt ?? "General";
   }
   return out;
 }
+function formatSelectionStat(workbook, stats, value) {
+  return formatValue(value, stats.numFmt ?? "General", { date1904: workbook.date1904 }).text;
+}
 function isOverflowTarget(sheet, row2, col) {
   const cell = getCell(sheet, row2, col);
   if (cell && (cell.value !== null && cell.value !== "" || cell.formula)) return false;
@@ -33099,7 +33838,7 @@ function chartAreaRect(model, part, area) {
 function chartBarSpacing(chart) {
   const stacked = chart.grouping === "stacked" || chart.grouping === "percentStacked";
   return {
-    barGapWidth: chart.barGapWidth ?? 150,
+    barGapWidth: chart.barGapWidth ?? DEFAULT_BAR_GAP_WIDTH,
     barOverlap: chart.barOverlap ?? (stacked ? 100 : 0)
   };
 }
@@ -34044,6 +34783,7 @@ exports.formatAxisValue = formatAxisValue;
 exports.formatGeneral = formatGeneral;
 exports.formatRange = formatRange;
 exports.formatRefSpec = formatRefSpec;
+exports.formatSelectionStat = formatSelectionStat;
 exports.formatValue = formatValue;
 exports.formulaBarText = formulaBarText;
 exports.functionMatches = functionMatches;