ooxml-core 0.11.0 → 0.13.0

package/dist/xlsx/index.mjs

@@ -9907,8 +9907,9 @@ var AreaIndex = class {
   wide = /* @__PURE__ */ new Map();
   add(area, node) {
     const { start, end } = area.range;
-    if (start.row === end.row && start.col === end.col) {
-      push2(inner(this.cells, area.sheet), cellKey(start.row, start.col), node);
+    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;
     }
     const entry = { range: area.range, node };
@@ -10135,7 +10136,8 @@ function writeFootprint(sheet, footprint, m) {
       }
       if (cell) {
         cell.value = value;
-        cell.spillAnchor = { row, col };
+        if (!isSpilledCell(cell) || cell.spillAnchor.row !== row || cell.spillAnchor.col !== col)
+          cell.spillAnchor = { row, col };
       } else {
         const spilled = { value, spillAnchor: { row, col } };
         putCell(sheet, r, c2, spilled);
@@ -10182,6 +10184,7 @@ var EngineHost = class {
   columnIndex;
   reverseIndex;
   footprintIndex;
+  fullOrder;
   /** Range reads cached for one evaluation pass (see `readBlock`). */
   blockCache = /* @__PURE__ */ new Map();
   /** Counts reads that hit a formula still being evaluated (a circular reference). */
@@ -10354,6 +10357,7 @@ var EngineHost = class {
     if (this.footprints.delete(node)) this.footprintIndex = void 0;
   }
   graphChanged() {
+    this.fullOrder = void 0;
     this.columnIndex = void 0;
     this.reverseIndex = void 0;
     this.footprintIndex = void 0;
@@ -10384,52 +10388,6 @@ var EngineHost = class {
   }
 };
 
-// src/xlsx/formula/engine-types.ts
-var CIRCULAR_REFERENCE_WARNING = "The workbook contains circular references; the cells involved show 0.";
-
-// src/xlsx/formula/engine-util.ts
-function finalize(value, host) {
-  let result2;
-  if (value instanceof RefValue) {
-    if (value.areas.length !== 1) return ERR.VALUE;
-    if (value.isCell()) {
-      const area = value.areas[0];
-      result2 = host.readCell(area.sheet, area.range.start.row, area.range.start.col);
-    } else result2 = toMatrix(host, value);
-  } else if (value instanceof LambdaValue) return ERR.CALC;
-  else result2 = value;
-  if (result2 instanceof Matrix) {
-    if (result2.rows === 1 && result2.cols === 1) result2 = result2.get(0, 0);
-    else return result2.block().mapValues(clean);
-  }
-  return clean(result2);
-}
-function clean(value) {
-  if (value === null) return 0;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) return ERR.NUM;
-    return value === 0 ? 0 : value;
-  }
-  return value;
-}
-var rangeHas = (range, row, col) => row >= range.start.row && row <= range.end.row && col >= range.start.col && col <= range.end.col;
-function sameRange(a, b) {
-  if (!a || !b) return a === b || !a && !b;
-  return 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 boundingBox(ranges) {
-  const first3 = ranges[0];
-  const start = { ...first3.start };
-  const end = { ...first3.end };
-  for (const r of ranges) {
-    start.row = Math.min(start.row, r.start.row);
-    start.col = Math.min(start.col, r.start.col);
-    end.row = Math.max(end.row, r.end.row);
-    end.col = Math.max(end.col, r.end.col);
-  }
-  return { start, end };
-}
-
 // src/xlsx/formula/scc.ts
 function stronglyConnected(nodes, successors) {
   const index2 = /* @__PURE__ */ new Map();
@@ -10482,6 +10440,63 @@ function stronglyConnected(nodes, successors) {
   return out;
 }
 
+// src/xlsx/formula/engine-order.ts
+function formulaOrder(nodes, successors) {
+  const ranks = /* @__PURE__ */ new Map();
+  const components = stronglyConnected(nodes, successors).map((members, rank4) => {
+    for (const member of members) ranks.set(member, rank4);
+    const first3 = members[0];
+    return { nodes: members, cyclic: members.length > 1 || successors(first3).includes(first3) };
+  });
+  return { components, ranks };
+}
+
+// src/xlsx/formula/engine-types.ts
+var CIRCULAR_REFERENCE_WARNING = "The workbook contains circular references; the cells involved show 0.";
+
+// src/xlsx/formula/engine-util.ts
+function finalize(value, host) {
+  let result2;
+  if (value instanceof RefValue) {
+    if (value.areas.length !== 1) return ERR.VALUE;
+    if (value.isCell()) {
+      const area = value.areas[0];
+      result2 = host.readCell(area.sheet, area.range.start.row, area.range.start.col);
+    } else result2 = toMatrix(host, value);
+  } else if (value instanceof LambdaValue) return ERR.CALC;
+  else result2 = value;
+  if (result2 instanceof Matrix) {
+    if (result2.rows === 1 && result2.cols === 1) result2 = result2.get(0, 0);
+    else return result2.block().mapValues(clean);
+  }
+  return clean(result2);
+}
+function clean(value) {
+  if (value === null) return 0;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return ERR.NUM;
+    return value === 0 ? 0 : value;
+  }
+  return value;
+}
+var rangeHas = (range, row, col) => row >= range.start.row && row <= range.end.row && col >= range.start.col && col <= range.end.col;
+function sameRange(a, b) {
+  if (!a || !b) return a === b || !a && !b;
+  return 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 boundingBox(ranges) {
+  const first3 = ranges[0];
+  const start = { ...first3.start };
+  const end = { ...first3.end };
+  for (const r of ranges) {
+    start.row = Math.min(start.row, r.start.row);
+    start.col = Math.min(start.col, r.start.col);
+    end.row = Math.max(end.row, r.end.row);
+    end.col = Math.max(end.col, r.end.col);
+  }
+  return { start, end };
+}
+
 // src/xlsx/formula/store.ts
 function storeResult(sheet, node, cell, result2, claims) {
   const { row, col } = node;
@@ -10501,9 +10516,9 @@ function storeResult(sheet, node, cell, result2, claims) {
     return;
   }
   const footprint = footprintFor(row, col, result2);
-  if (node.spill) clearFootprint(sheet, node.spill, row, col);
-  delete node.spill;
   if (!footprint || !footprintFree(sheet, footprint, row, col, claims)) {
+    if (node.spill) clearFootprint(sheet, node.spill, row, col);
+    delete node.spill;
     node.blockedSpill = footprint ?? {
       start: { row, col },
       end: {
@@ -10514,6 +10529,7 @@ function storeResult(sheet, node, cell, result2, claims) {
     cell.value = ERR.SPILL;
     return;
   }
+  if (node.spill && !sameRange(node.spill, footprint)) clearFootprint(sheet, node.spill, row, col);
   delete node.blockedSpill;
   writeFootprint(sheet, footprint, result2);
   node.spill = footprint;
@@ -10536,7 +10552,7 @@ var EngineCore = class extends EngineHost {
       const dirty = everything && round2 === 0 ? current : this.closure(current);
       this.footprintChanges = [];
       this.evaluatedAt = /* @__PURE__ */ new Map();
-      this.evaluateSet(dirty);
+      this.evaluateSet(dirty, everything && round2 === 0);
       if (this.footprintChanges.length === 0) break;
       const next = /* @__PURE__ */ new Set();
       const reverse2 = this.reverse();
@@ -10578,7 +10594,7 @@ var EngineCore = class extends EngineHost {
     }
     return out;
   }
-  evaluateSet(dirty) {
+  evaluateSet(dirty, full) {
     this.boundsCache.clear();
     this.blockCache.clear();
     const columns = this.columns();
@@ -10588,24 +10604,25 @@ var EngineCore = class extends EngineHost {
       let out = succCache.get(node);
       if (out) return out;
       const found = [];
+      const anchors = /* @__PURE__ */ new Set();
       for (const dep of node.deps) {
         columns.nodesIn(dep, found);
-        const anchors = [];
         footprints.dependents(dep.sheet, dep.range, anchors);
-        for (const anchor of anchors) if (anchor.spill ?? anchor.arrayRange) found.push(anchor);
       }
-      out = [...new Set(found)].filter((n2) => dirty.has(n2));
+      for (const anchor of anchors) if (anchor.spill ?? anchor.arrayRange) found.push(anchor);
+      out = found.length ? [...new Set(found)].filter((n2) => dirty.has(n2)) : [];
       succCache.set(node, out);
       return out;
     };
-    const order = stronglyConnected(dirty, successors);
+    const order = full && this.fullOrder || formulaOrder(dirty, successors);
+    if (full) this.fullOrder = order;
     this.pending = new Set(dirty);
     this.dynamicCycleHits = /* @__PURE__ */ new Set();
     try {
-      for (const component of order) {
-        const first3 = component[0];
-        if (component.length > 1 || successors(first3).includes(first3)) {
-          for (const node of component) this.markCycle(node);
+      for (const component of order.components) {
+        const first3 = component.nodes[0];
+        if (component.cyclic) {
+          for (const node of component.nodes) this.markCycle(node);
         } else if (this.pending.has(first3)) {
           this.computeFrom(first3);
         }
@@ -10684,6 +10701,7 @@ var EngineCore = class extends EngineHost {
       return !!other && other !== node && !!other.spill && rangeHas(other.spill, r, c2);
     });
     if (!sameRange(before, node.spill) || !sameRange(blockedBefore, node.blockedSpill)) {
+      this.updateOrder(node, before, blockedBefore);
       this.footprintIndex = void 0;
       this.blockCache.clear();
     }
@@ -10703,10 +10721,30 @@ var EngineCore = class extends EngineHost {
       }
     }
   }
+  /** New spill edges may reuse the order only when every reader already follows its anchor. */
+  updateOrder(node, before, blockedBefore) {
+    const order = this.fullOrder;
+    if (!order) return;
+    if (before || blockedBefore || !node.spill || node.blockedSpill) {
+      this.fullOrder = void 0;
+      return;
+    }
+    const rank4 = order.ranks.get(node);
+    if (rank4 === void 0) {
+      this.fullOrder = void 0;
+      return;
+    }
+    const readers = /* @__PURE__ */ new Set();
+    this.reverse().dependents(node.sheet, node.spill, readers);
+    for (const reader of readers) {
+      if ((order.ranks.get(reader) ?? -1) <= rank4) {
+        this.fullOrder = void 0;
+        return;
+      }
+    }
+  }
   frameFor(sheet, row, col, root, legacy = false) {
-    const frame = { host: this, sheet, row, col, scope: void 0, depth: 0 };
-    if (legacy) Object.assign(frame, { legacy: true });
-    return root ? { ...frame, root } : frame;
+    return { host: this, sheet, row, col, scope: void 0, depth: 0, root, legacy };
   }
   evaluateFormula(node) {
     if (!node.ast) return node.parseError ?? ERR.NAME;