ooxml-core 1.19.2 → 1.21.0

package/dist/xlsx/ui/index.cjs

@@ -321,9 +321,9 @@ function nextSheetName(workbook, base = "Sheet") {
 }
 var nextSheetId = (workbook) => workbook.sheets.reduce((max, sheet) => Math.max(max, sheet.sheetId), 0) + 1;
 
-// xlsx/styles.ts
-function styleKey(style3) {
-  return JSON.stringify(sortKeys(style3));
+// xlsx/stable-key.ts
+function stableKey(value3) {
+  return JSON.stringify(sortKeys(value3));
 }
 function sortKeys(value3) {
   if (Array.isArray(value3)) return value3.map(sortKeys);
@@ -337,6 +337,11 @@ function sortKeys(value3) {
   }
   return value3;
 }
+
+// xlsx/styles.ts
+function styleKey(style3) {
+  return stableKey(style3);
+}
 function styleAt(workbook, styleId) {
   const style3 = workbook.styles[styleId ?? 0] ?? workbook.styles[0];
   if (!style3) throw new Error("Workbook has no default cell style");
@@ -2709,6 +2714,37 @@ function parseArray(c2) {
   return { type: "array", rows: rows2 };
 }
 
+// xlsx/formula/change-areas.ts
+function changeAreas(changes) {
+  const out = [];
+  const open = /* @__PURE__ */ new Map();
+  let run2;
+  const close2 = (area) => {
+    const { start, end } = area.range;
+    const key = `${area.sheet}:${start.col}:${end.col}`;
+    const above = open.get(key);
+    if (above && above.range.end.row === start.row - 1) {
+      above.range.end.row = end.row;
+      return;
+    }
+    out.push(area);
+    open.set(key, area);
+  };
+  for (const { sheet, row: row2, col } of changes) {
+    if (run2 && run2.sheet === sheet && run2.range.start.row === row2) {
+      if (col === run2.range.end.col + 1) {
+        run2.range.end.col = col;
+        continue;
+      }
+      if (col >= run2.range.start.col && col <= run2.range.end.col) continue;
+    }
+    if (run2) close2(run2);
+    run2 = { sheet, range: { start: { row: row2, col }, end: { row: row2, col } } };
+  }
+  if (run2) close2(run2);
+  return out;
+}
+
 // xlsx/formula/date-serial.ts
 var DAY_MS = 864e5;
 var EPOCH_19002 = Date.UTC(1899, 11, 30);
@@ -2935,68 +2971,6 @@ var ReverseIndex = class extends AreaIndex {
   }
 };
 
-// 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(node2, cell) {
-    this.reverse.addNode(node2);
-    if (!node2.legacy && !node2.arrayRange) this.formulas.dynamic.push(node2);
-    if (cell.value === null && !node2.keepCached) this.formulas.unvalued.push(node2);
-  }
-  /** 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",
@@ -3399,6 +3373,311 @@ function finite(value3) {
   return value3;
 }
 
+// xlsx/formula/operators.ts
+var signal = (fn) => {
+  try {
+    return fn();
+  } catch (e) {
+    if (e instanceof ErrorSignal) return e.value;
+    throw e;
+  }
+};
+function power(base, exponent) {
+  if (base === 0 && exponent === 0) throw new ErrorSignal(ERR.NUM);
+  if (base === 0 && exponent < 0) throw new ErrorSignal(ERR.DIV0);
+  if (base < 0 && !Number.isInteger(exponent)) {
+    const inverse = 1 / exponent;
+    const odd = Math.round(inverse);
+    if (Math.abs(inverse - odd) < 1e-10 && Math.abs(odd) % 2 === 1) {
+      return -Math.pow(-base, exponent);
+    }
+    throw new ErrorSignal(ERR.NUM);
+  }
+  return Math.pow(base, exponent);
+}
+function snapToZero(result2, a2, b) {
+  if (result2 !== 0 && Math.abs(result2) <= Math.max(Math.abs(a2), Math.abs(b)) * 1e-15) return 0;
+  return result2;
+}
+function arithmetic(op2, x, y, snap) {
+  if (isError(x)) return x;
+  if (isError(y)) return y;
+  return signal(() => {
+    const a2 = toNumber(x);
+    const b = toNumber(y);
+    let r;
+    switch (op2) {
+      case "+":
+        r = a2 + b;
+        if (snap) r = snapToZero(r, a2, b);
+        break;
+      case "-":
+        r = a2 - b;
+        if (snap) r = snapToZero(r, a2, b);
+        break;
+      case "*":
+        r = a2 * b;
+        break;
+      case "/":
+        if (b === 0) return ERR.DIV0;
+        r = a2 / b;
+        break;
+      default:
+        r = power(a2, b);
+    }
+    return Number.isFinite(r) ? r === 0 ? 0 : r : ERR.NUM;
+  });
+}
+function comparison(op2, x, y) {
+  if (isError(x)) return x;
+  if (isError(y)) return y;
+  const c2 = compareScalars(x, y);
+  switch (op2) {
+    case "=":
+      return c2 === 0;
+    case "<>":
+      return c2 !== 0;
+    case "<":
+      return c2 < 0;
+    case ">":
+      return c2 > 0;
+    case "<=":
+      return c2 <= 0;
+    default:
+      return c2 >= 0;
+  }
+}
+function concat(x, y) {
+  if (isError(x)) return x;
+  if (isError(y)) return y;
+  return toText(x) + toText(y);
+}
+function scalarBinary(op2, x, y, snap = false) {
+  if (op2 === "&") return concat(x, y);
+  if (op2 === "+" || op2 === "-" || op2 === "*" || op2 === "/" || op2 === "^") {
+    return arithmetic(op2, x, y, snap);
+  }
+  return comparison(op2, x, y);
+}
+function scalarUnary(op2, x) {
+  if (isError(x)) return x;
+  return signal(() => {
+    const n2 = toNumber(x);
+    const r = op2 === "-" ? -n2 : n2 / 100;
+    return r === 0 ? 0 : r;
+  });
+}
+function pick(m, row2, col) {
+  const r = m.rows === 1 ? 0 : row2;
+  const c2 = m.cols === 1 ? 0 : col;
+  if (r >= m.rows || c2 >= m.cols) return ERR.NA;
+  return m.get(r, c2);
+}
+function broadcastShape(operands, at) {
+  let rows2 = 1;
+  let cols = 1;
+  for (const m of operands) {
+    rows2 = Math.max(rows2, m.rows);
+    cols = Math.max(cols, m.cols);
+  }
+  if (!operands.some((m) => m.isPadded)) return Matrix.build(rows2, cols, at);
+  let blockRows = 1;
+  let blockCols = 1;
+  for (const m of operands) {
+    blockRows = Math.max(blockRows, m.isPadded ? m.blockRows : m.rows);
+    blockCols = Math.max(blockCols, m.isPadded ? m.blockCols : m.cols);
+  }
+  blockRows = Math.min(blockRows, rows2);
+  blockCols = Math.min(blockCols, cols);
+  const varies = operands.some(
+    (m) => blockRows < rows2 && m.rows === 1 && m.cols > 1 || blockCols < cols && m.cols === 1 && m.rows > 1
+  );
+  if (varies) return Matrix.build(rows2, cols, at);
+  return Matrix.padded(Matrix.build(blockRows, blockCols, at), rows2, cols, at(rows2 - 1, cols - 1));
+}
+function broadcast2(a2, b, fn) {
+  if (!(a2 instanceof Matrix) && !(b instanceof Matrix)) return fn(a2, b);
+  const ma = a2 instanceof Matrix ? a2 : new Matrix([[a2]]);
+  const mb = b instanceof Matrix ? b : new Matrix([[b]]);
+  return broadcastShape([ma, mb], (r, c2) => fn(pick(ma, r, c2), pick(mb, r, c2)));
+}
+function broadcast1(a2, fn) {
+  return a2 instanceof Matrix ? a2.mapValues(fn) : fn(a2);
+}
+
+// xlsx/formula/spill.ts
+var isSpilledCell = (cell) => cell !== void 0 && "spillAnchor" in cell;
+function releaseSpilledCell(sheet, row2, col) {
+  const cell = getCell(sheet, row2, col);
+  if (!isSpilledCell(cell)) return;
+  delete cell.spillAnchor;
+  cell.value = null;
+  if (!cell.styleId && !cell.formula && !cell.richText && !cell.arrayRange)
+    deleteCell(sheet, row2, col);
+}
+function clearFootprint(sheet, footprint, row2, col) {
+  const { start, end } = footprint;
+  const owned = [];
+  const visit2 = (r, c2, cell) => {
+    if (c2 < start.col || c2 > end.col || r === row2 && c2 === col) return;
+    if (isSpilledCell(cell) && cell.spillAnchor.row === row2 && cell.spillAnchor.col === col)
+      owned.push([r, c2]);
+  };
+  const visitRow = (r, cells) => {
+    if (end.col - start.col + 1 <= cells.size)
+      for (let c2 = start.col; c2 <= end.col; c2++) visit2(r, c2, cells.get(c2));
+    else for (const [c2, cell] of cells) visit2(r, c2, cell);
+  };
+  if (end.row - start.row + 1 <= sheet.rows.size) {
+    for (let r = start.row; r <= end.row; r++) {
+      const cells = sheet.rows.get(r);
+      if (cells) visitRow(r, cells);
+    }
+  } else
+    for (const [r, cells] of sheet.rows) if (r >= start.row && r <= end.row) visitRow(r, cells);
+  for (const [r, c2] of owned) releaseSpilledCell(sheet, r, c2);
+}
+function footprintFor(row2, col, m) {
+  const end = { row: row2 + m.rows - 1, col: col + m.cols - 1 };
+  if (end.row > MAX_ROW || end.col > MAX_COL) return void 0;
+  return { start: { row: row2, col }, end };
+}
+function footprintFree(sheet, footprint, row2, col, claims) {
+  if (sheet.merges.some((m) => rangesIntersect(m, footprint))) return false;
+  for (let r = footprint.start.row; r <= footprint.end.row; r++) {
+    const cells = sheet.rows.get(r);
+    if (!cells) continue;
+    for (let c2 = footprint.start.col; c2 <= footprint.end.col; c2++) {
+      if (r === row2 && c2 === col) continue;
+      const cell = cells.get(c2);
+      if (!cell) continue;
+      if (cell.formula) return false;
+      if (isSpilledCell(cell)) {
+        const a2 = cell.spillAnchor;
+        if (a2.row === row2 && a2.col === col) continue;
+        if (claims(a2, r, c2)) return false;
+        continue;
+      }
+      if (cell.value !== null) return false;
+    }
+  }
+  return true;
+}
+function writeFootprint(sheet, footprint, m) {
+  const { row: row2, col } = footprint.start;
+  for (let r = footprint.start.row; r <= footprint.end.row; r++) {
+    for (let c2 = footprint.start.col; c2 <= footprint.end.col; c2++) {
+      const value3 = cellValueOf(m.get(r - row2, c2 - col));
+      const cell = getCell(sheet, r, c2);
+      if (r === row2 && c2 === col) {
+        if (cell) cell.value = value3;
+        continue;
+      }
+      if (cell) {
+        cell.value = value3;
+        if (!isSpilledCell(cell) || cell.spillAnchor.row !== row2 || cell.spillAnchor.col !== col)
+          cell.spillAnchor = { row: row2, col };
+      } else {
+        const spilled = { value: value3, spillAnchor: { row: row2, col } };
+        putCell(sheet, r, c2, spilled);
+      }
+    }
+  }
+}
+function fillArrayRange(sheet, range2, m) {
+  const { row: row2, col } = range2.start;
+  for (let r = range2.start.row; r <= range2.end.row; r++) {
+    for (let c2 = range2.start.col; c2 <= range2.end.col; c2++) {
+      const value3 = cellValueOf(pick(m, r - row2, c2 - col));
+      const cell = getCell(sheet, r, c2);
+      if (cell) cell.value = value3;
+      else putCell(sheet, r, c2, { value: value3 });
+    }
+  }
+}
+var cellValueOf = (value3) => value3 === null ? 0 : value3;
+
+// 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: [] };
+  /**
+   * The spills stored in the file, by sheet and anchor (`cellKey`): from the anchor to the last
+   * row and column of the cells marked as its results. Until the anchor is evaluated they are
+   * the only record of the cells it covers.
+   */
+  spills = /* @__PURE__ */ new Map();
+  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);
+      else if (isSpilledCell(cell)) this.addSpilled(this.row, col, cell.spillAnchor);
+      if (timeRemaining && ++visited % CHECK_EVERY === 0 && timeRemaining() <= 0) break;
+    }
+    return this.finished;
+  }
+  add(node2, cell) {
+    this.reverse.addNode(node2);
+    if (!node2.legacy && !node2.arrayRange) this.formulas.dynamic.push(node2);
+    if (cell.value === null && !node2.keepCached) this.formulas.unvalued.push(node2);
+  }
+  addSpilled(row2, col, anchor) {
+    if (row2 < anchor.row || col < anchor.col) return;
+    let spills = this.spills.get(this.sheet);
+    if (!spills) this.spills.set(this.sheet, spills = /* @__PURE__ */ new Map());
+    const key = cellKey(anchor.row, anchor.col);
+    const range2 = spills.get(key);
+    if (!range2) spills.set(key, { start: { ...anchor }, end: { row: row2, col } });
+    else {
+      range2.end.row = Math.max(range2.end.row, row2);
+      range2.end.col = Math.max(range2.end.col, col);
+    }
+  }
+  /** 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/functions/wildcard.ts
 var lower = (ch) => (ch ?? "").toLowerCase();
 var fold = (text4) => Array.from({ length: text4.length }, (_, i2) => lower(text4[i2]));
@@ -6872,138 +7151,6 @@ var INFO_FUNCTIONS = [
   )
 ];
 
-// xlsx/formula/operators.ts
-var signal = (fn) => {
-  try {
-    return fn();
-  } catch (e) {
-    if (e instanceof ErrorSignal) return e.value;
-    throw e;
-  }
-};
-function power(base, exponent) {
-  if (base === 0 && exponent === 0) throw new ErrorSignal(ERR.NUM);
-  if (base === 0 && exponent < 0) throw new ErrorSignal(ERR.DIV0);
-  if (base < 0 && !Number.isInteger(exponent)) {
-    const inverse = 1 / exponent;
-    const odd = Math.round(inverse);
-    if (Math.abs(inverse - odd) < 1e-10 && Math.abs(odd) % 2 === 1) {
-      return -Math.pow(-base, exponent);
-    }
-    throw new ErrorSignal(ERR.NUM);
-  }
-  return Math.pow(base, exponent);
-}
-function snapToZero(result2, a2, b) {
-  if (result2 !== 0 && Math.abs(result2) <= Math.max(Math.abs(a2), Math.abs(b)) * 1e-15) return 0;
-  return result2;
-}
-function arithmetic(op2, x, y, snap) {
-  if (isError(x)) return x;
-  if (isError(y)) return y;
-  return signal(() => {
-    const a2 = toNumber(x);
-    const b = toNumber(y);
-    let r;
-    switch (op2) {
-      case "+":
-        r = a2 + b;
-        if (snap) r = snapToZero(r, a2, b);
-        break;
-      case "-":
-        r = a2 - b;
-        if (snap) r = snapToZero(r, a2, b);
-        break;
-      case "*":
-        r = a2 * b;
-        break;
-      case "/":
-        if (b === 0) return ERR.DIV0;
-        r = a2 / b;
-        break;
-      default:
-        r = power(a2, b);
-    }
-    return Number.isFinite(r) ? r === 0 ? 0 : r : ERR.NUM;
-  });
-}
-function comparison(op2, x, y) {
-  if (isError(x)) return x;
-  if (isError(y)) return y;
-  const c2 = compareScalars(x, y);
-  switch (op2) {
-    case "=":
-      return c2 === 0;
-    case "<>":
-      return c2 !== 0;
-    case "<":
-      return c2 < 0;
-    case ">":
-      return c2 > 0;
-    case "<=":
-      return c2 <= 0;
-    default:
-      return c2 >= 0;
-  }
-}
-function concat(x, y) {
-  if (isError(x)) return x;
-  if (isError(y)) return y;
-  return toText(x) + toText(y);
-}
-function scalarBinary(op2, x, y, snap = false) {
-  if (op2 === "&") return concat(x, y);
-  if (op2 === "+" || op2 === "-" || op2 === "*" || op2 === "/" || op2 === "^") {
-    return arithmetic(op2, x, y, snap);
-  }
-  return comparison(op2, x, y);
-}
-function scalarUnary(op2, x) {
-  if (isError(x)) return x;
-  return signal(() => {
-    const n2 = toNumber(x);
-    const r = op2 === "-" ? -n2 : n2 / 100;
-    return r === 0 ? 0 : r;
-  });
-}
-function pick(m, row2, col) {
-  const r = m.rows === 1 ? 0 : row2;
-  const c2 = m.cols === 1 ? 0 : col;
-  if (r >= m.rows || c2 >= m.cols) return ERR.NA;
-  return m.get(r, c2);
-}
-function broadcastShape(operands, at) {
-  let rows2 = 1;
-  let cols = 1;
-  for (const m of operands) {
-    rows2 = Math.max(rows2, m.rows);
-    cols = Math.max(cols, m.cols);
-  }
-  if (!operands.some((m) => m.isPadded)) return Matrix.build(rows2, cols, at);
-  let blockRows = 1;
-  let blockCols = 1;
-  for (const m of operands) {
-    blockRows = Math.max(blockRows, m.isPadded ? m.blockRows : m.rows);
-    blockCols = Math.max(blockCols, m.isPadded ? m.blockCols : m.cols);
-  }
-  blockRows = Math.min(blockRows, rows2);
-  blockCols = Math.min(blockCols, cols);
-  const varies = operands.some(
-    (m) => blockRows < rows2 && m.rows === 1 && m.cols > 1 || blockCols < cols && m.cols === 1 && m.rows > 1
-  );
-  if (varies) return Matrix.build(rows2, cols, at);
-  return Matrix.padded(Matrix.build(blockRows, blockCols, at), rows2, cols, at(rows2 - 1, cols - 1));
-}
-function broadcast2(a2, b, fn) {
-  if (!(a2 instanceof Matrix) && !(b instanceof Matrix)) return fn(a2, b);
-  const ma = a2 instanceof Matrix ? a2 : new Matrix([[a2]]);
-  const mb = b instanceof Matrix ? b : new Matrix([[b]]);
-  return broadcastShape([ma, mb], (r, c2) => fn(pick(ma, r, c2), pick(mb, r, c2)));
-}
-function broadcast1(a2, fn) {
-  return a2 instanceof Matrix ? a2.mapValues(fn) : fn(a2);
-}
-
 // xlsx/formula/functions/lambda.ts
 var C16 = "Logical";
 function lambdaArg(value3) {
@@ -11741,6 +11888,19 @@ var DEFAULT_XML_LIMITS = {
   maxDepth: 512,
   maxNodes: 5e6
 };
+var XmlLimitError = class extends Error {
+  code = "xml-limit";
+  /** The limit that was exceeded. */
+  limit;
+  /** Its value: the largest depth or element count allowed. */
+  maximum;
+  constructor(message, limit2, maximum) {
+    super(message);
+    this.name = "XmlLimitError";
+    this.limit = limit2;
+    this.maximum = maximum;
+  }
+};
 var TAG_RE = /<(\/?)([^\s\/><]+)(?:\s+[^\s=\/><]+\s*=\s*(?:"[^"<]*"|'[^'<]*'))*\s*(\/?)>/y;
 var MARKUP_SKIPS = [
   ["<!--", "-->"],
@@ -11774,11 +11934,22 @@ function checkXmlLimits(xml, label2, limits = {}) {
       continue;
     }
     nodes++;
-    if (nodes > maxNodes) throw new Error(`${label2} XML exceeds the limit of ${maxNodes} elements`);
+    if (nodes > maxNodes)
+      throw new XmlLimitError(
+        `${label2} XML exceeds the limit of ${maxNodes} elements`,
+        "maxNodes",
+        maxNodes
+      );
     if (!selfClosing && ++depth > maxDepth)
-      throw new Error(`${label2} XML exceeds the nesting depth limit of ${maxDepth}`);
+      throw new XmlLimitError(
+        `${label2} XML exceeds the nesting depth limit of ${maxDepth}`,
+        "maxDepth",
+        maxDepth
+      );
   }
 }
+var CRLF_DECLARATION = /^<\?xml[^>]*\?>\r\n/;
+var crlfDeclarations = /* @__PURE__ */ new WeakSet();
 function parseXml(xml, options7 = {}) {
   const label2 = options7.label ?? "OOXML";
   if (/<!DOCTYPE|<!ENTITY/i.test(xml))
@@ -11800,9 +11971,13 @@ function parseXml(xml, options7 = {}) {
   }
   if (parseError || !parsed.documentElement)
     throw new Error(`Invalid ${label2} XML: ${parseError || "missing root element"}`);
+  if (CRLF_DECLARATION.test(xml)) crlfDeclarations.add(parsed);
   return parsed;
 }
-var buildXml = (node2) => new xmldom.XMLSerializer().serializeToString(node2);
+var buildXml = (node2) => {
+  const xml = new xmldom.XMLSerializer().serializeToString(node2);
+  return crlfDeclarations.has(node2) ? xml.replace(/^(<\?xml[^>]*\?>)\n/, "$1\r\n") : xml;
+};
 var isElement = (node2) => node2.nodeType === 1;
 var elements = (parent) => Array.from(parent.childNodes).filter(isElement);
 function named(element2, local, ns, lenient = true) {
@@ -11901,6 +12076,12 @@ function parseLiteFragment(xml, container, namespaces) {
     }
     if (lt < 0) break;
     const next = source2.charCodeAt(lt + 1);
+    if (next === 33) {
+      const after = skipCommentOrCdata(source2, lt, top);
+      if (after < 0) return void 0;
+      pos = after;
+      continue;
+    }
     if (next === 47) {
       const gt = source2.indexOf(">", lt);
       if (gt < 0 || stack2.length < 2 || source2.slice(lt + 2, gt).trimEnd() !== top.tagName)
@@ -11921,6 +12102,25 @@ function parseLiteFragment(xml, container, namespaces) {
   }
   return stack2.length === 1 ? root : void 0;
 }
+var DECLARATIONS = /<!DOCTYPE|<!ENTITY/i;
+function skipCommentOrCdata(source2, lt, parent) {
+  if (source2.startsWith("<!--", lt)) {
+    const end = source2.indexOf("-->", lt + 4);
+    if (end < 0) return -1;
+    const body2 = source2.slice(lt + 4, end);
+    if (body2.includes("--") || body2.endsWith("-") || DECLARATIONS.test(body2)) return -1;
+    return end + 3;
+  }
+  if (source2.startsWith("<![CDATA[", lt)) {
+    const end = source2.indexOf("]]>", lt + 9);
+    if (end < 0) return -1;
+    const text4 = source2.slice(lt + 9, end);
+    if (DECLARATIONS.test(text4)) return -1;
+    parent.childNodes.push(text4);
+    return end + 3;
+  }
+  return -1;
+}
 function startTag(source2, from, namespaces) {
   const n2 = source2.length;
   let i2 = from;
@@ -14894,89 +15094,6 @@ function sheetBounds(sheet) {
   return { rows: rows2, cols };
 }
 
-// xlsx/formula/spill.ts
-var isSpilledCell = (cell) => cell !== void 0 && "spillAnchor" in cell;
-function releaseSpilledCell(sheet, row2, col) {
-  const cell = getCell(sheet, row2, col);
-  if (!isSpilledCell(cell)) return;
-  delete cell.spillAnchor;
-  cell.value = null;
-  if (!cell.styleId && !cell.formula && !cell.richText && !cell.arrayRange)
-    deleteCell(sheet, row2, col);
-}
-function clearFootprint(sheet, footprint, row2, col) {
-  for (let r = footprint.start.row; r <= footprint.end.row; r++) {
-    const cells = sheet.rows.get(r);
-    if (!cells) continue;
-    for (let c2 = footprint.start.col; c2 <= footprint.end.col; c2++) {
-      if (r === row2 && c2 === col) continue;
-      const cell = cells.get(c2);
-      if (isSpilledCell(cell) && cell.spillAnchor.row === row2 && cell.spillAnchor.col === col) {
-        releaseSpilledCell(sheet, r, c2);
-      }
-    }
-  }
-}
-function footprintFor(row2, col, m) {
-  const end = { row: row2 + m.rows - 1, col: col + m.cols - 1 };
-  if (end.row > MAX_ROW || end.col > MAX_COL) return void 0;
-  return { start: { row: row2, col }, end };
-}
-function footprintFree(sheet, footprint, row2, col, claims) {
-  if (sheet.merges.some((m) => rangesIntersect(m, footprint))) return false;
-  for (let r = footprint.start.row; r <= footprint.end.row; r++) {
-    const cells = sheet.rows.get(r);
-    if (!cells) continue;
-    for (let c2 = footprint.start.col; c2 <= footprint.end.col; c2++) {
-      if (r === row2 && c2 === col) continue;
-      const cell = cells.get(c2);
-      if (!cell) continue;
-      if (cell.formula) return false;
-      if (isSpilledCell(cell)) {
-        const a2 = cell.spillAnchor;
-        if (a2.row === row2 && a2.col === col) continue;
-        if (claims(a2, r, c2)) return false;
-        continue;
-      }
-      if (cell.value !== null) return false;
-    }
-  }
-  return true;
-}
-function writeFootprint(sheet, footprint, m) {
-  const { row: row2, col } = footprint.start;
-  for (let r = footprint.start.row; r <= footprint.end.row; r++) {
-    for (let c2 = footprint.start.col; c2 <= footprint.end.col; c2++) {
-      const value3 = cellValueOf(m.get(r - row2, c2 - col));
-      const cell = getCell(sheet, r, c2);
-      if (r === row2 && c2 === col) {
-        if (cell) cell.value = value3;
-        continue;
-      }
-      if (cell) {
-        cell.value = value3;
-        if (!isSpilledCell(cell) || cell.spillAnchor.row !== row2 || cell.spillAnchor.col !== col)
-          cell.spillAnchor = { row: row2, col };
-      } else {
-        const spilled = { value: value3, spillAnchor: { row: row2, col } };
-        putCell(sheet, r, c2, spilled);
-      }
-    }
-  }
-}
-function fillArrayRange(sheet, range2, m) {
-  const { row: row2, col } = range2.start;
-  for (let r = range2.start.row; r <= range2.end.row; r++) {
-    for (let c2 = range2.start.col; c2 <= range2.end.col; c2++) {
-      const value3 = cellValueOf(pick(m, r - row2, c2 - col));
-      const cell = getCell(sheet, r, c2);
-      if (cell) cell.value = value3;
-      else putCell(sheet, r, c2, { value: value3 });
-    }
-  }
-}
-var cellValueOf = (value3) => value3 === null ? 0 : value3;
-
 // xlsx/formula/engine-host.ts
 var Deferred = class {
   constructor(node2) {
@@ -15901,6 +16018,8 @@ var Engine = class extends EngineStructure {
   preparation;
   /** The prepared formulas the first recalculation checks (see `trustsStoredValues`). */
   prepared;
+  /** Stored spills released when the graph was built: their readers must recalculate. */
+  released = [];
   // ---- the graph ----
   prepare(timeRemaining) {
     if (this.built || this.needsFull) return true;
@@ -15938,10 +16057,33 @@ var Engine = class extends EngineStructure {
   finishPreparation(preparation) {
     this.preparation = void 0;
     this.built = true;
+    this.adoptStoredSpills(preparation.spills);
     this.graphChanged();
     this.reverseIndex = preparation.reverse;
     this.prepared = preparation.formulas;
   }
+  /**
+   * Takes the spills a file stored as their anchors' last footprints, so that overwriting an
+   * anchor or shrinking its result clears the cells it covered before it was ever evaluated here.
+   * Cells marked for an anchor that holds no formula able to spill are released.
+   */
+  adoptStoredSpills(spills) {
+    for (const [s, anchors] of spills)
+      for (const [key, range2] of anchors) {
+        const node2 = this.nodes.get(s)?.get(key);
+        if (node2 && !node2.legacy && !node2.arrayRange) {
+          if (!node2.spill && !node2.blockedSpill) {
+            node2.spill = range2;
+            this.footprints.add(node2);
+          }
+          continue;
+        }
+        const sheet = this.workbook.sheets[s];
+        if (!sheet) continue;
+        clearFootprint(sheet, range2, range2.start.row, range2.start.col);
+        this.released.push({ sheet: s, range: range2 });
+      }
+  }
   // ---- recalculation ----
   recalculateAll() {
     resetArrayBudget();
@@ -15950,6 +16092,7 @@ var Engine = class extends EngineStructure {
     if (this.needsFull) this.releaseAllSpills();
     if (!this.built || this.needsFull) this.build();
     this.needsFull = false;
+    this.released = [];
     this.structuralSeeds.clear();
     this.cycles = /* @__PURE__ */ new Set();
     this.run(new Set(this.allNodes()), true);
@@ -15968,7 +16111,9 @@ var Engine = class extends EngineStructure {
       this.recalculateAll();
       return;
     }
-    const changed = [];
+    const changed = this.released;
+    this.released = [];
+    const written = [];
     let structural = false;
     for (const change of changes) {
       const sheet = this.workbook.sheets[change.sheet];
@@ -15988,7 +16133,8 @@ var Engine = class extends EngineStructure {
         seeds.add(this.createNode(change.sheet, row2, col, cell, false));
         structural = true;
       } else if (existing && formula) seeds.add(existing);
-      changed.push({ sheet: change.sheet, range: { start: { row: row2, col }, end: { row: row2, col } } });
+      written.push(change);
+      if (!this.footprints.size) continue;
       const anchors = [];
       this.footprintsBy().dependents(
         change.sheet,
@@ -16005,7 +16151,8 @@ var Engine = class extends EngineStructure {
     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 area of [...changed, ...changeAreas(written)])
+      reverse2.dependents(area.sheet, area.range, seeds);
     for (const node2 of this.allNodes()) if (node2.volatile) seeds.add(node2);
     this.run(seeds, false);
   }
@@ -16018,11 +16165,17 @@ var Engine = class extends EngineStructure {
     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)}`));
     const current = (node2) => this.nodes.get(node2.sheet)?.get(cellKey(node2.row, node2.col)) === node2;
-    for (const node2 of prepared.dynamic) {
-      if (current(node2) && !changed.has(`${node2.sheet}:${cellKey(node2.row, node2.col)}`))
-        return false;
+    const dynamic = prepared.dynamic.filter(current);
+    if (dynamic.length) {
+      const changed = /* @__PURE__ */ new Map();
+      for (const c2 of changes) {
+        let keys = changed.get(c2.sheet);
+        if (!keys) changed.set(c2.sheet, keys = /* @__PURE__ */ new Set());
+        keys.add(cellKey(c2.row, c2.col));
+      }
+      for (const node2 of dynamic)
+        if (!changed.get(node2.sheet)?.has(cellKey(node2.row, node2.col))) return false;
     }
     for (const node2 of prepared.unvalued) {
       const cell = this.workbook.sheets[node2.sheet]?.rows.get(node2.row)?.get(node2.col);
@@ -16750,10 +16903,13 @@ var DEFAULT_ZIP_LIMITS = {
 var ZipLimitError = class extends Error {
   code = "ZIP_BOMB";
   limit;
+  /** The check that failed (absent when the error was built without one). */
+  kind;
   constructor(message, details) {
     super(message);
     this.name = "ZipLimitError";
     this.limit = details.limit;
+    this.kind = details.kind;
   }
 };
 var mib = (bytes) => Math.round(bytes / 1048576);
@@ -16776,7 +16932,7 @@ function resolveLimits(limits) {
     maxEntryBytes: limits.maxEntryBytes ?? DEFAULT_ZIP_LIMITS.maxEntryBytes,
     maxTotalBytes: limits.maxTotalBytes ?? DEFAULT_ZIP_LIMITS.maxTotalBytes,
     label: limits.label ?? "ZIP",
-    fail: (message, limit2) => create ? create(message, { limit: limit2 }) : new ZipLimitError(message, { limit: limit2 })
+    fail: (message, limit2, kind) => create ? create(message, { limit: limit2, kind }) : new ZipLimitError(message, { limit: limit2, kind })
   };
 }
 function inflateEntryGuarded(entry3, alreadyRead, limits) {
@@ -16799,13 +16955,18 @@ function inflateEntryGuarded(entry3, alreadyRead, limits) {
       size += chunk.byteLength;
       if (size > declared || size > r.maxEntryBytes)
         return abort(
-          r.fail(`${r.label} part ${entry3.name} inflates past its declared size`, r.maxEntryBytes)
+          r.fail(
+            `${r.label} part ${entry3.name} inflates past its declared size`,
+            r.maxEntryBytes,
+            size > declared ? "declaredSize" : "maxEntryBytes"
+          )
         );
       if (alreadyRead + size > r.maxTotalBytes)
         return abort(
           r.fail(
             `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
-            r.maxTotalBytes
+            r.maxTotalBytes,
+            "maxTotalBytes"
           )
         );
       chunks.push(chunk);
@@ -16838,26 +16999,29 @@ function guardZip(zip, limits = {}) {
   if (entries.length > r.maxEntries)
     throw r.fail(
       `${r.label} package exceeds the ${r.maxEntries.toLocaleString("en-US")} part limit`,
-      r.maxEntries
+      r.maxEntries,
+      "maxEntries"
     );
   let declared = 0;
   for (const entry3 of entries) {
     const original = entry3.unsafeOriginalName;
     if (!isSafePartName(entry3.name) || original !== void 0 && !isSafePartName(original))
-      throw r.fail(`${r.label} package has an unsafe part name`, r.maxEntries);
+      throw r.fail(`${r.label} package has an unsafe part name`, r.maxEntries, "partName");
     if (entry3.dir) continue;
     const size = declaredEntrySize(entry3);
     if (size > r.maxEntryBytes)
       throw r.fail(
         `${r.label} part ${entry3.name} exceeds the uncompressed part size limit`,
-        r.maxEntryBytes
+        r.maxEntryBytes,
+        "maxEntryBytes"
       );
     declared += size;
   }
   if (declared > r.maxTotalBytes)
     throw r.fail(
       `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
-      r.maxTotalBytes
+      r.maxTotalBytes,
+      "maxTotalBytes"
     );
   const produced = /* @__PURE__ */ new Map();
   let total2 = 0;
@@ -18900,10 +19064,69 @@ function mergeComments(legacy, threaded) {
     (a2, b) => a2.address.row - b.address.row || a2.address.col - b.address.col
   );
 }
-var MAX_INPUT_BYTES = 50 * 1024 * 1024;
-var MAX_PARTS = 1e4;
-var MAX_UNCOMPRESSED_BYTES = 300 * 1024 * 1024;
-var MAX_PART_BYTES = 200 * 1024 * 1024;
+
+// xlsx/read/limits.ts
+var DEFAULT_XLSX_LOAD_LIMITS = {
+  maxInputBytes: 50 * 1024 * 1024,
+  maxParts: 1e4,
+  maxPartBytes: 200 * 1024 * 1024,
+  maxTotalBytes: 300 * 1024 * 1024,
+  maxXmlElements: 5e6
+};
+var WorkbookTooLargeError = class extends Error {
+  code = "workbook-too-large";
+  /** The limit that was exceeded, as named in {@link XlsxLoadLimits}. */
+  limit;
+  /** The value of that limit when the load failed. */
+  maximum;
+  constructor(message, limit2, maximum, options7) {
+    super(message, options7);
+    this.name = "WorkbookTooLargeError";
+    this.limit = limit2;
+    this.maximum = maximum;
+  }
+};
+function resolveLoadLimits(limits = {}) {
+  const resolved = { ...DEFAULT_XLSX_LOAD_LIMITS };
+  for (const name of Object.keys(resolved)) {
+    const value3 = limits[name];
+    if (value3 === void 0) continue;
+    if (!Number.isFinite(value3) || value3 <= 0)
+      throw new RangeError(`limits.${name} must be a positive finite number`);
+    resolved[name] = value3;
+  }
+  return resolved;
+}
+var ZIP_LIMIT_NAMES = {
+  maxInputBytes: "maxInputBytes",
+  maxEntries: "maxParts",
+  maxEntryBytes: "maxPartBytes",
+  maxTotalBytes: "maxTotalBytes"
+};
+function zipLimitsFor(limits) {
+  return {
+    maxInputBytes: limits.maxInputBytes,
+    maxEntries: limits.maxParts,
+    maxEntryBytes: limits.maxPartBytes,
+    maxTotalBytes: limits.maxTotalBytes,
+    label: "XLSX",
+    createError: (message, { limit: limit2, kind }) => {
+      const name = ZIP_LIMIT_NAMES[kind];
+      return name ? new WorkbookTooLargeError(message, name, limit2) : new ZipLimitError(message, { limit: limit2, kind });
+    }
+  };
+}
+function parseDataXml(xml, label2, maxXmlElements = DEFAULT_XLSX_LOAD_LIMITS.maxXmlElements) {
+  try {
+    return parseXml(xml, { label: label2, limits: { maxNodes: maxXmlElements } });
+  } catch (error) {
+    if (error instanceof XmlLimitError && error.limit === "maxNodes")
+      throw new WorkbookTooLargeError(error.message, "maxXmlElements", error.maximum, {
+        cause: error
+      });
+    throw error;
+  }
+}
 var CONTENT_TYPES = {
   workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
   workbookMacro: "application/vnd.ms-excel.sheet.macroEnabled.main+xml",
@@ -18993,16 +19216,15 @@ var SourceIndex = class {
 };
 var mib2 = (bytes) => Math.round(bytes / 1048576);
 async function readZipParts(input, limits = {}) {
-  const maxInput = limits.maxInputBytes ?? MAX_INPUT_BYTES;
-  const zipLimits = {
-    maxEntries: limits.maxParts ?? MAX_PARTS,
-    maxEntryBytes: limits.maxPartBytes ?? MAX_PART_BYTES,
-    maxTotalBytes: limits.maxTotalBytes ?? MAX_UNCOMPRESSED_BYTES,
-    label: "XLSX"
-  };
+  const resolved = resolveLoadLimits(limits);
+  const maxInput = resolved.maxInputBytes;
   const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
   if (bytes.byteLength > maxInput)
-    throw new Error(`XLSX package exceeds the ${mib2(maxInput)} MiB compressed input limit`);
+    throw new WorkbookTooLargeError(
+      `XLSX package exceeds the ${mib2(maxInput)} MiB compressed input limit`,
+      "maxInputBytes",
+      maxInput
+    );
   let loaded;
   try {
     loaded = await JSZip2__default.default.loadAsync(bytes);
@@ -19012,7 +19234,7 @@ async function readZipParts(input, limits = {}) {
       { cause: error }
     );
   }
-  const zip = guardZip(loaded, zipLimits);
+  const zip = guardZip(loaded, zipLimitsFor(resolved));
   const parts = /* @__PURE__ */ new Map();
   for (const entry3 of Object.values(zip.files)) {
     if (entry3.dir) continue;
@@ -19219,9 +19441,9 @@ function parseRichString(element2, palette) {
   const text4 = parsed.map((run2) => run2.text).join("");
   return { text: text4, runs: parsed };
 }
-function parseSharedStrings(xml, palette) {
+function parseSharedStrings(xml, palette, maxXmlElements) {
   if (!xml) return [];
-  const root = parseXml(xml, { label: "XLSX shared strings" }).documentElement;
+  const root = parseDataXml(xml, "XLSX shared strings", maxXmlElements).documentElement;
   return xChildren(root, "si").map((si) => parseRichString(si, palette));
 }
 
@@ -24594,21 +24816,50 @@ function rootNamespaces(xml) {
   for (const match2 of (root[2] ?? "").matchAll(DECLARATION2)) out[match2[1] ?? ""] = match2[3] ?? "";
   return out;
 }
+var SPECIAL = /<[!?]/g;
+var SECTIONS = [
+  ["<!--", "-->"],
+  ["<![CDATA[", "]]>"],
+  ["<?", "?>"]
+];
+function blankComments(xml) {
+  if (!xml.includes("<!--") && !xml.includes("<![CDATA[")) return xml;
+  const pieces = [];
+  let copied = 0;
+  SPECIAL.lastIndex = 0;
+  for (let match2 = SPECIAL.exec(xml); match2; match2 = SPECIAL.exec(xml)) {
+    const at = match2.index;
+    const section = SECTIONS.find(([open2]) => xml.startsWith(open2, at));
+    if (!section) return void 0;
+    const [open, close2] = section;
+    const end = xml.indexOf(close2, at + open.length);
+    if (end < 0) return void 0;
+    const after = end + close2.length;
+    if (open !== "<?") {
+      pieces.push(xml.slice(copied, at), " ".repeat(after - at));
+      copied = after;
+    }
+    SPECIAL.lastIndex = after;
+  }
+  pieces.push(xml.slice(copied));
+  return pieces.join("");
+}
 function splitSheetData(xml) {
-  if (xml.includes("<!--") || xml.includes("<![CDATA[")) return void 0;
-  const namespaces = rootNamespaces(xml);
-  const open = OPEN.exec(xml);
+  const plain3 = blankComments(xml);
+  if (plain3 === void 0) return void 0;
+  const namespaces = rootNamespaces(plain3);
+  const open = OPEN.exec(plain3);
   if (!namespaces || !open) return void 0;
   const prefix = (open[1] ?? "").slice(0, -1);
   const ns = namespaces[prefix];
   if (prefix && ns === void 0) return void 0;
   const tagName = `${open[1] ?? ""}sheetData`;
-  const openEnd = xml.indexOf(">", open.index);
+  const openEnd = plain3.indexOf(">", open.index);
   if (openEnd < 0) return void 0;
-  const attributes = xml.slice(open.index + tagName.length + 1, openEnd);
+  const attributes = plain3.slice(open.index + tagName.length + 1, openEnd);
   if (attributes.trimEnd().endsWith("/") || attributes.includes("xmlns")) return void 0;
-  const close2 = xml.indexOf(`</${tagName}`, openEnd);
-  if (close2 < 0 || OPEN.test(xml.slice(openEnd))) return void 0;
+  const close2 = plain3.indexOf(`</${tagName}`, openEnd);
+  if (close2 < 0 || OPEN.test(plain3.slice(openEnd))) return void 0;
   const container = new LiteElement(tagName, "sheetData", ns || null);
   const data = parseLiteFragment(xml.slice(openEnd + 1, close2), container, namespaces);
   if (!data) return void 0;
@@ -24813,7 +25064,11 @@ function parseWorksheet(ctx, partName, name, sheetId) {
     return sheet;
   }
   const split = splitSheetData(xml);
-  const root = parseXml(split?.xml ?? xml, { label: "XLSX worksheet" }).documentElement;
+  const root = parseDataXml(
+    split?.xml ?? xml,
+    "XLSX worksheet",
+    ctx.maxXmlElements
+  ).documentElement;
   const byName = /* @__PURE__ */ new Map();
   const cfBlocks = [];
   for (const node2 of elements(root)) {
@@ -24887,8 +25142,9 @@ function liftPrintAreas(workbook) {
     return false;
   });
 }
-async function loadXlsx(input) {
-  const parts = await readZipParts(input);
+async function loadXlsx(input, options7 = {}) {
+  const limits = resolveLoadLimits(options7.limits);
+  const parts = await readZipParts(input, limits);
   const source2 = new SourceIndex(parts);
   const workbookPart = source2.workbookPart();
   if (!workbookPart) throw new Error("XLSX package has no workbook part (xl/workbook.xml)");
@@ -24909,7 +25165,8 @@ async function loadXlsx(input) {
     source: source2,
     sharedStrings: parseSharedStrings(
       stringsPart ? source2.text(stringsPart) : void 0,
-      styles.palette
+      styles.palette,
+      limits.maxXmlElements
     ),
     xfMap: styles.xfMap,
     date1904: book.date1904,
@@ -24917,7 +25174,8 @@ async function loadXlsx(input) {
     dxfs: styles.dxfs,
     persons: parsePersons(personsPart ? source2.text(personsPart) : void 0),
     dynamicCells: parseDynamicArrayMetadata(metadataPart ? source2.text(metadataPart) : void 0),
-    warn
+    warn,
+    maxXmlElements: limits.maxXmlElements
   };
   const rels = source2.rels(workbookPart);
   const sheets = book.sheets.map((entry3) => {
@@ -29229,10 +29487,8 @@ function sheetFormatXml(sheet) {
   const current = { defaultRowHeight: sheet.defaultRowHeight };
   if (sheet.defaultColWidth !== void 0) current.defaultColWidth = sheet.defaultColWidth;
   if (sheet.format && Object.keys(sheet.format).length) current.format = sheet.format;
-  const rowLevel = Math.max(
-    0,
-    ...[...sheet.rowInfo.values()].map((info) => info.outlineLevel ?? 0)
-  );
+  let rowLevel = 0;
+  for (const info of sheet.rowInfo.values()) rowLevel = Math.max(rowLevel, info.outlineLevel ?? 0);
   const colLevel = Math.max(0, ...sheet.columns.map((col) => col.outlineLevel ?? 0));
   if (source2 && sameModel(readSheetFormat(source2), current) && Number(source2.getAttribute("outlineLevelRow") ?? 0) === rowLevel && Number(source2.getAttribute("outlineLevelCol") ?? 0) === colLevel)
     return snapshotXml(sheet, "sheetFormatPr") ?? "";
@@ -29534,11 +29790,10 @@ function pivotCacheDefinitionXml(pivot, workbook, data, recordRel) {
     const items = data.items[index3];
     if (pivot.dateFields?.includes(name) && items.every((v) => typeof v === "number")) {
       const serials = items;
-      const latest = Math.max(...serials);
-      const maxDate = Number.isInteger(latest) ? latest + 1 : latest;
+      const range2 = dateGroupRange({}, serials);
       const parent = derived.filter((entry3) => entry3.group.field === name).at(-1);
       const link = parent ? `<fieldGroup par="${parent.index}"/>` : "";
-      return `<cacheField${attrs({ name: encodeEscapes(name), numFmtId: 14 })}><sharedItems${attrs({ containsSemiMixedTypes: false, containsNonDate: false, containsDate: true, containsString: false, minDate: iso(Math.min(...serials)), maxDate: iso(maxDate), count: serials.length })}>${serials.map((serial) => `<d v="${iso(serial)}"/>`).join("")}</sharedItems>${link}</cacheField>`;
+      return `<cacheField${attrs({ name: encodeEscapes(name), numFmtId: 14 })}><sharedItems${attrs({ containsSemiMixedTypes: false, containsNonDate: false, containsDate: true, containsString: false, minDate: iso(range2.start), maxDate: iso(range2.end), count: serials.length })}>${serials.map((serial) => `<d v="${iso(serial)}"/>`).join("")}</sharedItems>${link}</cacheField>`;
     }
     const types = new Set(
       items.map((value3) => value3 === null || value3 === "" ? "blank" : typeof value3)
@@ -30953,7 +31208,8 @@ function setCellValue(ctx, s, row2, col, value3) {
 }
 function setRangeValues(ctx, s, at, values2) {
   const sheet = sheetAt(ctx.workbook, s);
-  const width = Math.max(0, ...values2.map((row2) => row2.length));
+  let width = 0;
+  for (const row2 of values2) width = Math.max(width, row2.length);
   if (!values2.length || !width) return;
   const range2 = cellRange(at.row, at.col, at.row + values2.length - 1, at.col + width - 1);
   ctx.run(
@@ -32277,23 +32533,33 @@ function toHtml(cells, theme2) {
       for (let c2 = m.start.col; c2 <= m.end.col; c2++)
         if (r !== m.start.row || c2 !== m.start.col) covered.add(`${r},${c2}`);
   }
+  const styleAttrs = /* @__PURE__ */ new Map();
+  const styleAttr2 = (style3) => {
+    let attr2 = styleAttrs.get(style3);
+    if (attr2 === void 0) {
+      const css = cssFor(style3, theme2);
+      styleAttrs.set(style3, attr2 = css ? `style="${escapeHtml(css)}"` : "");
+    }
+    return attr2;
+  };
   const rows2 = [];
   for (let r = 0; r < cells.rows; r++) {
     const tds = [];
     for (let c2 = 0; c2 < cells.cols; c2++) {
-      if (covered.has(`${r},${c2}`)) continue;
+      const key = covered.size || spans3.size || links.size ? `${r},${c2}` : "";
+      if (covered.has(key)) continue;
       const cell = cells.data[r]?.[c2] ?? null;
       const attrs2 = [];
-      const span4 = spans3.get(`${r},${c2}`);
+      const span4 = spans3.get(key);
       if (span4 && span4.end.row > span4.start.row)
         attrs2.push(`rowspan="${span4.end.row - span4.start.row + 1}"`);
       if (span4 && span4.end.col > span4.start.col)
         attrs2.push(`colspan="${span4.end.col - span4.start.col + 1}"`);
       if (cell && typeof cell.value === "number") attrs2.push(`x:num="${cell.value}"`);
-      const css = cssFor(cell?.style, theme2);
-      if (css) attrs2.push(`style="${escapeHtml(css)}"`);
+      const css = styleAttr2(cell?.style);
+      if (css) attrs2.push(css);
       let text4 = escapeHtml(cell?.text ?? "").replace(/\n/g, "<br>");
-      const link = links.get(`${r},${c2}`);
+      const link = links.get(key);
       const href = htmlHref(link);
       if (href)
         text4 = `<a href="${escapeHtml(href)}"${link?.tooltip ? ` title="${escapeHtml(link.tooltip)}"` : ""}>${text4}</a>`;
@@ -32601,7 +32867,8 @@ function parseTsv(text4) {
   }
   row2.push(field);
   rows2.push(row2);
-  const width = Math.max(...rows2.map((r) => r.length));
+  let width = 0;
+  for (const r of rows2) width = Math.max(width, r.length);
   for (const r of rows2) while (r.length < width) r.push("");
   return rows2;
 }
@@ -32856,10 +33123,16 @@ function copyRange(workbook, s, range2) {
     { length: rows2 },
     () => Array.from({ length: cols }, () => null)
   );
+  const styles = /* @__PURE__ */ new Map();
+  const styleCopy = (id) => {
+    let style3 = styles.get(id ?? 0);
+    if (!style3) styles.set(id ?? 0, style3 = structuredClone(styleAt(workbook, id)));
+    return style3;
+  };
   forEachCellInRange(sheet, clipped, (cell, row2, col) => {
     const clip = {
       value: cell.value,
-      style: structuredClone(styleAt(workbook, cell.styleId)),
+      style: styleCopy(cell.styleId),
       text: displayText(workbook, cell)
     };
     if (cell.formula !== void 0) clip.formula = cell.formula;
@@ -33137,7 +33410,7 @@ function setColumnWidth(ctx, s, cols, width, measure3) {
   ctx.run(
     "Column width",
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "parts", sheet: s, parts: ["columns"] }],
     () => editColumns(sheet, cols, (info) => {
       const next = widths.get(info.min);
       if (next === void 0) {
@@ -33172,7 +33445,7 @@ function setRowHeight(ctx, s, rows2, height) {
   ctx.run(
     "Row height",
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "rowInfo", sheet: s, rows: rows2 }],
     () => {
       for (const row2 of rows2) {
         const info = { ...sheet.rowInfo.get(row2) };
@@ -33202,7 +33475,9 @@ function setHidden(ctx, s, axis, indices, hidden) {
   ctx.run(
     `${hidden ? "Hide" : "Unhide"} ${noun}`,
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [
+      axis === "col" ? { kind: "parts", sheet: s, parts: ["columns"] } : { kind: "rowInfo", sheet: s, rows: indices }
+    ],
     () => {
       if (axis === "col") {
         editColumns(sheet, indices, (info) => {
@@ -33796,6 +34071,30 @@ function shiftEdgeCells(sheet, spec2, phase) {
   return out;
 }
 
+// xlsx/edit/clone-cell.ts
+function cloneCell(cell) {
+  const copy2 = { ...cell };
+  const fields = copy2;
+  for (const key of Object.keys(fields)) {
+    const value3 = fields[key];
+    if (typeof value3 === "object" && value3 !== null) fields[key] = structuredClone(value3);
+  }
+  return copy2;
+}
+
+// xlsx/edit/history-rows.ts
+function captureRowInfo(sheet, rows2) {
+  return [...new Set(rows2)].map((row2) => {
+    const info = sheet.rowInfo.get(row2);
+    return [row2, info && structuredClone(info)];
+  });
+}
+function restoreRowInfo(sheet, entries) {
+  for (const [row2, info] of entries)
+    if (info) sheet.rowInfo.set(row2, structuredClone(info));
+    else sheet.rowInfo.delete(row2);
+}
+
 // xlsx/edit/history.ts
 var SETTING_KEYS = [
   "structureLocked",
@@ -33823,12 +34122,14 @@ function restoreSettings(workbook, settings) {
 var PROBE_LIMIT = 4096;
 function captureCells(sheet, ranges) {
   const cells = [];
-  const seen = /* @__PURE__ */ new Set();
+  const seen = ranges.length > 1 ? /* @__PURE__ */ new Set() : void 0;
   const take2 = (cell, row2, col) => {
-    const key = `${row2},${col}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    cells.push([row2, col, structuredClone(cell)]);
+    if (seen) {
+      const key = cellKey(row2, col);
+      if (seen.has(key)) return;
+      seen.add(key);
+    }
+    cells.push([row2, col, cloneCell(cell)]);
   };
   for (const raw2 of ranges) {
     const range2 = normalizeRange(raw2);
@@ -33880,6 +34181,8 @@ function captureScope(workbook, scope, before) {
   if (!sheet) throw new RangeError(`No sheet at index ${scope.sheet}`);
   if (scope.kind === "sheet")
     return { kind: "sheet", sheet: scope.sheet, data: structuredClone(sheet) };
+  if (scope.kind === "rowInfo")
+    return { kind: "rowInfo", sheet: scope.sheet, rows: captureRowInfo(sheet, scope.rows) };
   if (scope.kind === "parts") {
     const data = {};
     for (const part of scope.parts) if (sheet[part] !== void 0) data[part] = sheet[part];
@@ -33903,7 +34206,7 @@ function restoreShift(workbook, snapshot) {
   if (!sheet) return;
   const shift2 = snapshot.phase === "before" ? { ...spec2.shift, count: -spec2.shift.count } : spec2.shift;
   moveCellsRaw(sheet, shift2, spec2.band);
-  for (const [row2, col, cell] of snapshot.cells) putCell(sheet, row2, col, structuredClone(cell));
+  for (const [row2, col, cell] of snapshot.cells) putCell(sheet, row2, col, cloneCell(cell));
   restoreRefs(workbook, snapshot.data);
   workbook.activeSheet = snapshot.activeSheet;
 }
@@ -33931,6 +34234,7 @@ function restoreSnapshot(workbook, snapshot) {
   }
   const sheet = workbook.sheets[snapshot.sheet];
   if (!sheet) return;
+  if (snapshot.kind === "rowInfo") return restoreRowInfo(sheet, snapshot.rows);
   if (snapshot.kind === "parts") {
     const target2 = sheet;
     const data = structuredClone(snapshot.data);
@@ -33951,18 +34255,51 @@ function restoreSnapshot(workbook, snapshot) {
     forEachCellInRange(sheet, range2, (_cell, row2, col) => doomed.push([row2, col]));
     for (const [row2, col] of doomed) deleteCell(sheet, row2, col);
   }
-  for (const [row2, col, cell] of snapshot.cells) putCell(sheet, row2, col, structuredClone(cell));
+  for (const [row2, col, cell] of snapshot.cells) putCell(sheet, row2, col, cloneCell(cell));
+}
+function rowMajor(cells) {
+  for (let i2 = 1; i2 < cells.length; i2++) {
+    const [row0, col0] = cells[i2 - 1];
+    const [row1, col1] = cells[i2];
+    if (row1 < row0 || row1 === row0 && col1 <= col0) return false;
+  }
+  return true;
 }
 function touchedCells(step) {
   const out = [];
-  const seen = /* @__PURE__ */ new Set();
+  const lists = step.entries.flatMap((entry3) => [entry3.before, entry3.after]).filter((snapshot) => snapshot.kind === "cells" && snapshot.cells.length > 0);
+  const [first2, second, ...rest] = lists;
+  if (first2 && !rest.length && (!second || second.sheet === first2.sheet)) {
+    const sheet = first2.sheet;
+    for (const [row2, col] of first2.cells) out.push({ sheet, row: row2, col });
+    if (!second) return out;
+    if (rowMajor(first2.cells) && rowMajor(second.cells)) {
+      let i2 = 0;
+      for (const [row2, col] of second.cells) {
+        const key = cellKey(row2, col);
+        while (i2 < first2.cells.length) {
+          const [r, c2] = first2.cells[i2];
+          if (cellKey(r, c2) >= key) break;
+          i2++;
+        }
+        const at = first2.cells[i2];
+        if (at && cellKey(at[0], at[1]) === key) continue;
+        out.push({ sheet, row: row2, col });
+      }
+      return out;
+    }
+    out.length = 0;
+  }
+  const seen = /* @__PURE__ */ new Map();
   for (const entry3 of step.entries)
     for (const snapshot of [entry3.before, entry3.after]) {
       if (snapshot.kind !== "cells") continue;
+      let keys = seen.get(snapshot.sheet);
+      if (!keys) seen.set(snapshot.sheet, keys = /* @__PURE__ */ new Set());
       for (const [row2, col] of snapshot.cells) {
-        const key = `${snapshot.sheet},${row2},${col}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
+        const key = cellKey(row2, col);
+        if (keys.has(key)) continue;
+        keys.add(key);
         out.push({ sheet: snapshot.sheet, row: row2, col });
       }
     }
@@ -34059,7 +34396,7 @@ var SessionCalculator = class {
       }
       this.calc.discardPreparation();
       if (structural) this.staleGraph = true;
-      else this.dirty.push(...touchedCells(step));
+      else for (const cell of touchedCells(step)) this.dirty.push(cell);
       return;
     }
     if (hint && !this.staleGraph) {
@@ -34078,7 +34415,7 @@ var SessionCalculator = class {
       this.calc.discardPreparation();
       if (!this.enabled) return;
       if (structural) this.staleGraph = true;
-      else this.dirty.push(...cells);
+      else for (const cell of cells) this.dirty.push(cell);
       return;
     }
     this.recalc(structural, () => cells);
@@ -35140,8 +35477,16 @@ function insertTimeline(ctx, s, ref) {
   const pivot = sheet.pivotTables?.find((entry3) => entry3.name === ref.pivot);
   if (!pivot || !pivot.dateFields?.includes(ref.field))
     throw new Error("Choose a PivotTable with a date field.");
-  const dates = pivot.records.map((record) => record[pivot.fields.indexOf(ref.field)]).filter((value3) => typeof value3 === "number");
-  if (!dates.length) throw new Error("Choose a PivotTable with a date field.");
+  const column2 = pivot.fields.indexOf(ref.field);
+  let earliest = Infinity;
+  let latest = -Infinity;
+  for (const record of pivot.records) {
+    const value3 = record[column2];
+    if (typeof value3 !== "number") continue;
+    earliest = Math.min(earliest, value3);
+    latest = Math.max(latest, value3);
+  }
+  if (earliest > latest) throw new Error("Choose a PivotTable with a date field.");
   const taken = /* @__PURE__ */ new Set([
     ...(workbook.slicers?.slicers ?? []).map((entry3) => entry3.name.toLowerCase()),
     ...(workbook.slicers?.timelines ?? []).map((entry3) => entry3.name.toLowerCase()),
@@ -35159,8 +35504,8 @@ function insertTimeline(ctx, s, ref) {
     "_"
   );
   const bounds = boundsOfSerialRange(
-    serialToIso(Math.min(...dates), workbook.date1904),
-    serialToIso(Math.max(...dates), workbook.date1904)
+    serialToIso(earliest, workbook.date1904),
+    serialToIso(latest, workbook.date1904)
   );
   const metrics = createGridMetrics(sheet, { zoom: 100 });
   let right2 = 0;
@@ -36323,12 +36668,13 @@ function span2(from, to) {
 }
 function outlineRows(ctx, s, from, to, delta) {
   const sheet = sheetAt(ctx.workbook, s);
+  const rows2 = span2(from, to);
   ctx.run(
     delta > 0 ? "Group rows" : "Ungroup rows",
     "structure",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "rowInfo", sheet: s, rows: rows2 }],
     () => {
-      for (const row2 of span2(from, to)) {
+      for (const row2 of rows2) {
         const info = { ...sheet.rowInfo.get(row2) };
         const level2 = nextLevel(info.outlineLevel, delta);
         if (level2) info.outlineLevel = level2;
@@ -36348,7 +36694,7 @@ function outlineColumns(ctx, s, from, to, delta) {
   ctx.run(
     delta > 0 ? "Group columns" : "Ungroup columns",
     "structure",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "parts", sheet: s, parts: ["columns"] }],
     () => editColumns(sheet, span2(from, to), (info) => {
       const level2 = nextLevel(info.outlineLevel, delta);
       if (level2) info.outlineLevel = level2;
@@ -36371,7 +36717,7 @@ function setDefaultColumnWidth(ctx, s, width) {
   ctx.run(
     "Standard width",
     "format",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "parts", sheet: s, parts: ["defaultColWidth"] }],
     () => {
       if (width === void 0) Reflect.deleteProperty(sheet, "defaultColWidth");
       else sheet.defaultColWidth = width;
@@ -38573,6 +38919,15 @@ function mergeFont(base, font) {
     if (value3 !== void 0) out[key] = value3;
   return out;
 }
+function cellFont(font, defaultFont) {
+  const out = { ...font };
+  if (!out.name && !out.scheme) {
+    if (defaultFont.name) out.name = defaultFont.name;
+    if (defaultFont.scheme) out.scheme = defaultFont.scheme;
+  }
+  if (!out.size && defaultFont.size) out.size = defaultFont.size;
+  return out;
+}
 function fontView(font, theme2) {
   const family = font.scheme === "major" ? theme2.majorFont || font.name || "Calibri Light" : font.scheme === "minor" ? theme2.minorFont || font.name || "Calibri" : font.name || theme2.minorFont || "Calibri";
   const view = {
@@ -38697,14 +39052,7 @@ function cellView(workbook, sheetIndex2, row2, col, cf, options7 = {}) {
   const style3 = styleAt(workbook, effectiveStyleId(sheet, row2, col));
   const conditional = cf?.at(row2, col);
   const dxf = conditional?.style;
-  const defaultFont = workbook.styles[0]?.font ?? {};
-  const base = { ...style3.font };
-  if (!base.name && !base.scheme) {
-    if (defaultFont.name) base.name = defaultFont.name;
-    if (defaultFont.scheme) base.scheme = defaultFont.scheme;
-  }
-  if (!base.size && defaultFont.size) base.size = defaultFont.size;
-  const font = mergeFont(base, dxf?.font);
+  const font = mergeFont(cellFont(style3.font, workbook.styles[0]?.font ?? {}), dxf?.font);
   const formulaText = sheet.view.showFormulas && cell?.formula !== void 0 ? `=${cell.formula}` : void 0;
   const shown = formulaText !== void 0 ? { text: formulaText } : displayText2(value3, style3, dxf?.numFmt ?? style3.numFmt, workbook, sheet);
   const fontViewResolved = fontView(font, workbook.theme);
@@ -38955,10 +39303,11 @@ function autoGrowRows(ctx, s, rows2, measure3 = approximateMeasure) {
     updates.push([row2, next]);
   }
   if (!updates.length) return [];
+  const changed = updates.map(([row2]) => row2);
   ctx.run(
     "Row height",
     "view",
-    [{ kind: "sheet", sheet: s }],
+    [{ kind: "rowInfo", sheet: s, rows: changed }],
     () => {
       for (const [row2, height] of updates) {
         const info = { ...sheet.rowInfo.get(row2) };
@@ -38970,7 +39319,7 @@ function autoGrowRows(ctx, s, rows2, measure3 = approximateMeasure) {
     },
     { sheet: s, structural: true }
   );
-  return updates.map(([row2]) => row2);
+  return changed;
 }
 var MAX_REFIT_ROWS = 1e4;
 function rowsToRefit(sheet, ranges) {
@@ -40300,14 +40649,24 @@ function formatAxisValue(value3, percent = false) {
   return `${v < 0 ? "-" : ""}${grouped}${frac ? `.${frac}` : ""}`;
 }
 
+// chart/extent.ts
+function extentOf(values2) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const value3 of values2) {
+    min = Math.min(min, value3);
+    max = Math.max(max, value3);
+  }
+  return { min, max };
+}
+
 // chart/axis-range.ts
 function computeLogValueRange(series, logBase) {
   const allValues = series.flatMap((item) => item.values).filter((value3) => value3 !== null && Number.isFinite(value3) && value3 > 0);
   if (allValues.length === 0) {
     return { min: 1, max: logBase, span: 1, logScale: true, logBase };
   }
-  const dataMin = Math.min(...allValues);
-  const dataMax = Math.max(...allValues);
+  const { min: dataMin, max: dataMax } = extentOf(allValues);
   const logMin = Math.floor(Math.log(dataMin) / Math.log(logBase));
   const logMax = Math.ceil(Math.log(dataMax) / Math.log(logBase));
   const min = logBase ** logMin;
@@ -41334,8 +41693,7 @@ function computeHistogramBins(values2, options7, format = String) {
     });
   }
   if (regular.length > 0) {
-    const min = Math.min(...regular.map((item) => item.value));
-    const max = Math.max(...regular.map((item) => item.value));
+    const { min, max } = extentOf(regular.map((item) => item.value));
     const requestedSize = options7.binSize && options7.binSize > 0 ? options7.binSize : void 0;
     const requestedCount = options7.binCount && options7.binCount > 0 ? options7.binCount : void 0;
     const start = requestedSize ? Math.floor(min / requestedSize) * requestedSize : min;
@@ -41463,8 +41821,9 @@ function waterfallView(chart, model, ctx) {
     colors: { increase: role(0), decrease: role(1), total: role(2) }
   };
   const ends = steps.flatMap((step) => [step.startValue, step.endValue]);
+  const range2 = extentOf(ends);
   model.valueAxis = {
-    ...ends.length ? niceScale(Math.min(...ends), Math.max(...ends)) : niceScale(0, 1),
+    ...ends.length ? niceScale(range2.min, range2.max) : niceScale(0, 1),
     percent: false
   };
   const labels = model.categories;
@@ -41580,7 +41939,8 @@ function chartSummaryView(chart, theme2, options7 = {}) {
       s.xValues = s.values.map((_, k) => numeric2 ? toNumber2(cats[k] ?? null) : k + 1);
     });
     const xs = series.flatMap((s) => s.xValues ?? []).filter((x) => x !== null);
-    model.xAxis = xs.length ? niceScale(Math.min(...xs), Math.max(...xs)) : niceScale(0, 1);
+    const range2 = extentOf(xs);
+    model.xAxis = xs.length ? niceScale(range2.min, range2.max) : niceScale(0, 1);
   }
   if (type === "stock") model.stock = stockView(chart.stock, ctx);
   if (type === "bubble") bubbleView(chart, model, ctx.evaluateRef);
@@ -41857,8 +42217,9 @@ function fitChartTrendline(options7, xVals, yVals) {
   }
   const model = fitModel(options7, xVals, yVals);
   if (!model) return noFit();
-  const startX = Math.min(...xVals) - (options7.backward ?? 0);
-  const endX = Math.max(...xVals) + (options7.forward ?? 0);
+  const xRange = extentOf(xVals);
+  const startX = xRange.min - (options7.backward ?? 0);
+  const endX = xRange.max + (options7.forward ?? 0);
   const steps = Math.max(Math.ceil((endX - startX) * 4), 20);
   const points = [];
   for (let step = 0; step <= steps; step++) {
@@ -42427,7 +42788,7 @@ function cartesianAxes(model, area, out) {
   const cats = Math.max(1, model.categories.length);
   const catW = Math.min(
     area.w * 0.3,
-    Math.max(...model.categories.map((c2) => textWidth(c2, categorySize)), 8) + 6
+    Math.max(extentOf(model.categories.map((c2) => textWidth(c2, categorySize))).max, 8) + 6
   );
   const second = horizontal2 ? void 0 : model.secondaryAxis;
   const secondLabels = second?.ticks.map((t) => axisTickText(t, model.axes?.secondary, second.percent)) ?? [];
@@ -42616,7 +42977,7 @@ function computeBubbleRadius(sizeVal, maxBubble, medianRadius, options7) {
   return medianRadius * scale2 * 0.5 + ratio * medianRadius * scale2 * 1.5;
 }
 function maxBubbleSize(sizes) {
-  return sizes.length > 0 ? Math.max(1, ...sizes.map(Math.abs)) : 1;
+  return Math.max(1, extentOf(sizes.map(Math.abs)).max);
 }
 function medianBubbleRadius(plotWidth, plotHeight) {
   return Math.min(plotWidth, plotHeight) * 0.04;
@@ -43229,13 +43590,11 @@ function chartLegendSvg(model, area, frame, options7) {
     chartAreaRect(model, "legend", { x: manual.x, y: manual.y, w: manual.width, h: manual.height })
   ];
   const baselineOffset = font ? (font.ascent - font.descent) / 2 : size * 0.35;
+  const widest = extentOf(widths).max;
   entries.forEach((entry3, i2) => {
     const available = horizontal2 ? chartTextWidth(entry3.label, attrs2, options7) : Math.max(0, rowWidth - size / 2 - keySize - keyGap);
     const label2 = fitChartText(entry3.label, available, attrs2, options7);
-    const contentWidth = Math.min(
-      horizontal2 ? widths[i2] ?? 0 : Math.max(...widths),
-      rowWidth - size / 2
-    );
+    const contentWidth = Math.min(horizontal2 ? widths[i2] ?? 0 : widest, rowWidth - size / 2);
     const x = horizontal2 ? horizontalX : manual.x + Math.max(size / 4, (rowWidth - contentWidth) / 2);
     const centerY = manual.y + (horizontal2 ? 0 : i2 * rowHeight) + rowHeight / 2;
     markup.push(rect(x, centerY - keySize / 2, keySize, keySize, entry3.color));
@@ -43307,7 +43666,7 @@ function automaticLegend(model, area, out, options7, bounds) {
   }
   const width = Math.min(
     area.w * 0.35,
-    Math.max(...entries.map((e) => chartTextWidth(e.label, attrs2, options7))) + 22
+    extentOf(entries.map((e) => chartTextWidth(e.label, attrs2, options7))).max + 22
   );
   const height = entries.length * rowH;
   const x = pos === "l" ? area.x + 4 : area.x + area.w - width;
@@ -55333,6 +55692,53 @@ function applyThemeColors(host, previous, colors) {
   return Object.keys(vars);
 }
 
+// xlsx/ui/selection-format.ts
+function selectionFormatting(workbook, sheetIndex2, ranges) {
+  const values2 = {
+    bold: /* @__PURE__ */ new Set(),
+    italic: /* @__PURE__ */ new Set(),
+    underline: /* @__PURE__ */ new Set(),
+    fontFamily: /* @__PURE__ */ new Set(),
+    fontSize: /* @__PURE__ */ new Set(),
+    alignment: /* @__PURE__ */ new Set(),
+    numberFormat: /* @__PURE__ */ new Set()
+  };
+  const sheet = workbook?.sheets[sheetIndex2];
+  let remaining = 4096;
+  let complete = true;
+  if (workbook && sheet)
+    outer: for (const raw2 of ranges) {
+      const range2 = normalizeRange(raw2);
+      for (let row2 = range2.start.row; row2 <= range2.end.row; row2++) {
+        for (let col = range2.start.col; col <= range2.end.col; col++) {
+          if (--remaining < 0) {
+            complete = false;
+            break outer;
+          }
+          const style3 = styleAt(workbook, effectiveStyleId(sheet, row2, col));
+          values2.bold.add(Boolean(style3.font.bold));
+          values2.italic.add(Boolean(style3.font.italic));
+          values2.underline.add(Boolean(style3.font.underline));
+          values2.fontFamily.add(style3.font.name ?? "Aptos");
+          values2.fontSize.add(style3.font.size ?? 11);
+          values2.alignment.add(style3.alignment?.horizontal ?? "general");
+          values2.numberFormat.add(style3.numFmt ?? "General");
+        }
+      }
+    }
+  const single = (set) => complete && set.size === 1 ? [...set][0] : null;
+  return {
+    bold: single(values2.bold),
+    italic: single(values2.italic),
+    underline: single(values2.underline),
+    fontFamily: single(values2.fontFamily),
+    fontSize: single(values2.fontSize),
+    alignment: single(values2.alignment),
+    numberFormat: single(values2.numberFormat),
+    formattingComplete: complete
+  };
+}
+
 exports.ACCOUNTING_FORMATS = ACCOUNTING_FORMATS;
 exports.ALL_RANGE = ALL_RANGE;
 exports.AUTOSUM_FUNCTIONS = AUTOSUM_FUNCTIONS;
@@ -55514,6 +55920,7 @@ exports.selectCell = selectCell;
 exports.selectSpecial = selectSpecial;
 exports.selectTab = selectTab;
 exports.selectionCellCount = selectionCellCount;
+exports.selectionFormatting = selectionFormatting;
 exports.selectionRef = selectionRef;
 exports.setTabHidden = setTabHidden;
 exports.sheetBaseName = sheetBaseName;