ooxml-core 1.8.3 → 1.9.0

package/dist/xlsx/ui/index.mjs

@@ -27,19 +27,19 @@ var isCellError = (value2) => typeof value2 === "object" && value2 !== null && "
 var MAX_ROW = 1048575;
 var MAX_COL = 16383;
 function columnLabel(col) {
-  let label2 = "";
+  let label3 = "";
   let n = col + 1;
   while (n > 0) {
     const rem = (n - 1) % 26;
-    label2 = String.fromCharCode(65 + rem) + label2;
+    label3 = String.fromCharCode(65 + rem) + label3;
     n = Math.floor((n - 1) / 26);
   }
-  return label2;
+  return label3;
 }
-function columnIndex(label2) {
-  if (!/^[A-Za-z]{1,3}$/.test(label2)) return -1;
+function columnIndex(label3) {
+  if (!/^[A-Za-z]{1,3}$/.test(label3)) return -1;
   let n = 0;
-  for (const ch of label2.toUpperCase()) n = n * 26 + (ch.charCodeAt(0) - 64);
+  for (const ch of label3.toUpperCase()) n = n * 26 + (ch.charCodeAt(0) - 64);
   return n - 1;
 }
 var formatAddress = (address2) => `${columnLabel(address2.col)}${address2.row + 1}`;
@@ -351,23 +351,23 @@ function compact(value2) {
   for (const [key, entry] of Object.entries(value2)) if (entry !== void 0) out[key] = entry;
   return out;
 }
-function patchStyle(base, patch) {
+function patchStyle(base, patch2) {
   const next = {
-    font: patch.font ? compact({ ...base.font, ...patch.font }) : base.font,
-    fill: patch.fill ?? base.fill,
-    border: patch.border ? compact({ ...base.border, ...patch.border }) : base.border,
-    numFmt: patch.numFmt ?? base.numFmt
+    font: patch2.font ? compact({ ...base.font, ...patch2.font }) : base.font,
+    fill: patch2.fill ?? base.fill,
+    border: patch2.border ? compact({ ...base.border, ...patch2.border }) : base.border,
+    numFmt: patch2.numFmt ?? base.numFmt
   };
-  const alignment = patch.alignment ? compact({ ...base.alignment, ...patch.alignment }) : base.alignment;
+  const alignment = patch2.alignment ? compact({ ...base.alignment, ...patch2.alignment }) : base.alignment;
   if (alignment && Object.keys(alignment).length) next.alignment = alignment;
-  const protection = patch.protection ? compact({ ...base.protection, ...patch.protection }) : base.protection;
+  const protection = patch2.protection ? compact({ ...base.protection, ...patch2.protection }) : base.protection;
   if (protection && Object.keys(protection).length) next.protection = protection;
-  const styleName = "cellStyleName" in patch ? patch.cellStyleName : base.cellStyleName;
+  const styleName = "cellStyleName" in patch2 ? patch2.cellStyleName : base.cellStyleName;
   if (styleName) next.cellStyleName = styleName;
   return next;
 }
-function applyStylePatch(workbook, styleId, patch) {
-  return internStyle(workbook, patchStyle(styleAt(workbook, styleId), patch));
+function applyStylePatch(workbook, styleId, patch2) {
+  return internStyle(workbook, patchStyle(styleAt(workbook, styleId), patch2));
 }
 
 // xlsx/cell-styles.ts
@@ -853,7 +853,7 @@ function compileFraction(tokens, slash) {
   while (isDigit(tokens[denEnd]) || tokens[denEnd]?.t === "num") denEnd++;
   const denTokens = tokens.slice(slash + 1, denEnd);
   const fixed2 = denTokens.some((t) => t.t === "num") && denTokens.every((t) => t.t === "num" || isDigit(t) && t.c === "0");
-  const plan = {
+  const plan2 = {
     tokens: [],
     intDigits: [],
     numDigits: [],
@@ -861,31 +861,31 @@ function compileFraction(tokens, slash) {
     denWidth: denTokens.length
   };
   if (fixed2) {
-    plan.fixedDenominator = Number(denTokens.map((t) => t.t === "num" ? t.v : "0").join(""));
+    plan2.fixedDenominator = Number(denTokens.map((t) => t.t === "num" ? t.v : "0").join(""));
   }
   tokens.forEach((tok, i2) => {
-    if (i2 === slash) plan.tokens.push({ r: "slash" });
+    if (i2 === slash) plan2.tokens.push({ r: "slash" });
     else if (i2 > slash && i2 < denEnd) {
       if (fixed2) {
-        if (i2 === slash + 1) plan.tokens.push({ r: "den", index: 0 });
+        if (i2 === slash + 1) plan2.tokens.push({ r: "den", index: 0 });
       } else if (isDigit(tok)) {
-        plan.tokens.push({ r: "den", index: plan.denDigits.length });
-        plan.denDigits.push(tok.c);
+        plan2.tokens.push({ r: "den", index: plan2.denDigits.length });
+        plan2.denDigits.push(tok.c);
       }
     } else if (isDigit(tok) && i2 >= numStart && i2 < slash) {
-      plan.tokens.push({ r: "num", index: plan.numDigits.length });
-      plan.numDigits.push(tok.c);
+      plan2.tokens.push({ r: "num", index: plan2.numDigits.length });
+      plan2.numDigits.push(tok.c);
     } else if (isDigit(tok) && i2 < numStart) {
-      plan.tokens.push({ r: "int", index: plan.intDigits.length });
-      plan.intDigits.push(tok.c);
-    } else if (tok.t === "lit") plan.tokens.push({ r: "lit", v: tok.v });
-    else if (tok.t === "num") plan.tokens.push({ r: "lit", v: tok.v });
-    else if (tok.t === "digit") plan.tokens.push({ r: "lit", v: tok.c });
-    else if (tok.t === "point") plan.tokens.push({ r: "lit", v: "." });
-    else if (tok.t === "slash") plan.tokens.push({ r: "lit", v: "/" });
-    else if (tok.t === "percent") plan.tokens.push({ r: "lit", v: "%" });
+      plan2.tokens.push({ r: "int", index: plan2.intDigits.length });
+      plan2.intDigits.push(tok.c);
+    } else if (tok.t === "lit") plan2.tokens.push({ r: "lit", v: tok.v });
+    else if (tok.t === "num") plan2.tokens.push({ r: "lit", v: tok.v });
+    else if (tok.t === "digit") plan2.tokens.push({ r: "lit", v: tok.c });
+    else if (tok.t === "point") plan2.tokens.push({ r: "lit", v: "." });
+    else if (tok.t === "slash") plan2.tokens.push({ r: "lit", v: "/" });
+    else if (tok.t === "percent") plan2.tokens.push({ r: "lit", v: "%" });
   });
-  return plan;
+  return plan2;
 }
 function approximate(x, maxDen) {
   if (Number.isInteger(x)) return [x, 1];
@@ -920,29 +920,29 @@ function padRight(s, slots) {
   for (let i2 = s.length; i2 < slots.length; i2++) suffix += pad(slots[i2] ?? "#");
   return s + suffix;
 }
-function renderFraction(value2, plan) {
+function renderFraction(value2, plan2) {
   const x = Math.abs(value2);
-  const hasInt = plan.intDigits.length > 0;
+  const hasInt = plan2.intDigits.length > 0;
   let ip = hasInt ? Math.floor(x) : 0;
   const f6 = x - ip;
-  const maxDen = 10 ** Math.max(1, plan.denDigits.length) - 1;
-  let [n, d] = plan.fixedDenominator ? [Math.round(f6 * plan.fixedDenominator), plan.fixedDenominator] : approximate(f6, maxDen);
+  const maxDen = 10 ** Math.max(1, plan2.denDigits.length) - 1;
+  let [n, d] = plan2.fixedDenominator ? [Math.round(f6 * plan2.fixedDenominator), plan2.fixedDenominator] : approximate(f6, maxDen);
   if (hasInt && n >= d) {
     ip += 1;
     n = 0;
   }
   const zero = !hasInt && n === 0;
   const blank = hasInt && n === 0;
-  const intText = hasInt ? padLeft(ip > 0 ? String(ip) : n === 0 ? "0" : "", plan.intDigits) : "";
+  const intText = hasInt ? padLeft(ip > 0 ? String(ip) : n === 0 ? "0" : "", plan2.intDigits) : "";
   const allHash = (slots) => slots.every((c) => c === "#");
-  const numHash = allHash(plan.numDigits);
-  const hideFraction = blank && numHash && (plan.fixedDenominator !== void 0 || allHash(plan.denDigits));
+  const numHash = allHash(plan2.numDigits);
+  const hideFraction = blank && numHash && (plan2.fixedDenominator !== void 0 || allHash(plan2.denDigits));
   const dropSeparator = hideFraction || hasInt && intText === "" && numHash;
-  const lastInt = plan.tokens.reduce((last, t, i2) => t.r === "int" ? i2 : last, -1);
-  const firstNum = plan.tokens.findIndex((t) => t.r === "num");
+  const lastInt = plan2.tokens.reduce((last, t, i2) => t.r === "int" ? i2 : last, -1);
+  const firstNum = plan2.tokens.findIndex((t) => t.r === "num");
   let text2 = "";
   let intDone = false;
-  plan.tokens.forEach((tok, i2) => {
+  plan2.tokens.forEach((tok, i2) => {
     if (tok.r === "lit") {
       if (!(dropSeparator && i2 > lastInt && i2 < firstNum)) text2 += tok.v;
     } else if (tok.r === "int") {
@@ -951,12 +951,12 @@ function renderFraction(value2, plan) {
     } else if (hideFraction) ; else if (blank) {
       if (tok.r === "num") text2 += " ";
       else if (tok.r === "slash") text2 += " ";
-      else text2 += " ".repeat(plan.fixedDenominator ? plan.denWidth : 1);
+      else text2 += " ".repeat(plan2.fixedDenominator ? plan2.denWidth : 1);
     } else if (tok.r === "num") {
-      if (tok.index === 0) text2 += padLeft(String(n), plan.numDigits);
+      if (tok.index === 0) text2 += padLeft(String(n), plan2.numDigits);
     } else if (tok.r === "slash") text2 += "/";
-    else if (plan.fixedDenominator) text2 += String(d);
-    else if (tok.index === 0) text2 += padRight(String(d), plan.denDigits);
+    else if (plan2.fixedDenominator) text2 += String(d);
+    else if (tok.index === 0) text2 += padRight(String(d), plan2.denDigits);
   });
   return { text: text2, zero };
 }
@@ -1097,15 +1097,15 @@ function compileNumber(tokens) {
     out.splice(at < 0 ? 0 : at, 0, { r: "int", c: "#", index: 0 });
     intDigits.push("#");
   }
-  const plan = {
+  const plan2 = {
     tokens: out,
     intDigits,
     fracDigits,
     grouping,
     shift: 2 * percent - 3 * scaleCommas
   };
-  if (exponent) plan.exponent = exponent;
-  return plan;
+  if (exponent) plan2.exponent = exponent;
+  return plan2;
 }
 var pad2 = (c) => c === "0" ? "0" : c === "?" ? " " : "";
 function placeIntegers(digits2, slots, grouping) {
@@ -1138,40 +1138,40 @@ function placeFraction(digits2, slots) {
   }
   return out;
 }
-function scientific(v, plan) {
+function scientific(v, plan2) {
   if (isZero(v)) return { value: v, exp: 0 };
-  const n = plan.intDigits.length;
-  const engineering = n > 1 && plan.intDigits.some((c) => c !== "0");
+  const n = plan2.intDigits.length;
+  const engineering = n > 1 && plan2.intDigits.some((c) => c !== "0");
   const period = engineering ? n : 1;
   const e = v.point - 1;
   let exp2 = Math.floor(e / period) * period;
-  let m = roundDecimals(shift(v, -exp2), plan.fracDigits.length);
+  let m = roundDecimals(shift(v, -exp2), plan2.fracDigits.length);
   if (m.point > period) {
     exp2 += period;
-    m = roundDecimals(shift(v, -exp2), plan.fracDigits.length);
+    m = roundDecimals(shift(v, -exp2), plan2.fracDigits.length);
   }
   return { value: m, exp: exp2 };
 }
-function renderNumber(value2, plan) {
-  const v = shift(toDigits(value2), plan.shift);
+function renderNumber(value2, plan2) {
+  const v = shift(toDigits(value2), plan2.shift);
   let rounded;
   let exp2 = 0;
-  if (plan.exponent) {
-    const m = scientific(v, plan);
+  if (plan2.exponent) {
+    const m = scientific(v, plan2);
     rounded = m.value;
     exp2 = m.exp;
-  } else rounded = roundDecimals(v, plan.fracDigits.length);
-  const ints = plan.exponent && isZero(rounded) ? plan.intDigits.map(() => "0") : placeIntegers(integerPart(rounded), plan.intDigits, plan.grouping);
-  const fracs = placeFraction(fractionPart(rounded, plan.fracDigits.length), plan.fracDigits);
+  } else rounded = roundDecimals(v, plan2.fracDigits.length);
+  const ints = plan2.exponent && isZero(rounded) ? plan2.intDigits.map(() => "0") : placeIntegers(integerPart(rounded), plan2.intDigits, plan2.grouping);
+  const fracs = placeFraction(fractionPart(rounded, plan2.fracDigits.length), plan2.fracDigits);
   let text2 = "";
-  for (const tok of plan.tokens) {
+  for (const tok of plan2.tokens) {
     if (tok.r === "lit") text2 += tok.v;
     else if (tok.r === "int") text2 += ints[tok.index] ?? "";
     else if (tok.r === "frac") text2 += fracs[tok.index] ?? "";
     else if (tok.r === "point") text2 += ".";
-    else if (plan.exponent) {
-      const sign2 = exp2 < 0 ? "-" : plan.exponent.plus ? "+" : "";
-      text2 += `E${sign2}${String(Math.abs(exp2)).padStart(plan.exponent.digits, "0")}`;
+    else if (plan2.exponent) {
+      const sign2 = exp2 < 0 ? "-" : plan2.exponent.plus ? "+" : "";
+      text2 += `E${sign2}${String(Math.abs(exp2)).padStart(plan2.exponent.digits, "0")}`;
     }
   }
   return { text: text2, zero: isZero(rounded) };
@@ -1864,9 +1864,9 @@ function parseFractionInput(text2) {
   const m = /^([-+]?)(\d+)\s+(\d+)\/(\d+)$/.exec(text2.trim());
   if (!m) return void 0;
   const den = Number(m[4]);
-  const num2 = Number(m[3]);
-  if (den === 0 || num2 >= den) return void 0;
-  const magnitude = Number(m[2]) + num2 / den;
+  const num3 = Number(m[3]);
+  if (den === 0 || num3 >= den) return void 0;
+  const magnitude = Number(m[2]) + num3 / den;
   return {
     value: m[1] === "-" ? -magnitude : magnitude,
     numFmt: den < 10 ? "# ?/?" : "# ??/??"
@@ -11159,13 +11159,27 @@ var TEXT_REGEX_FUNCTIONS = [
     "REGEXEXTRACT",
     C35,
     "REGEXEXTRACT(text, pattern, [return_mode], [case_sensitivity])",
-    "The first part of the text that matches the pattern.",
+    "Extracts the first match (0), all matches (1), or the first match\u2019s capture groups (2).",
     2,
     4,
     (args) => {
-      if (optNum(args, 2, 0) !== 0) fail(ERR.VALUE);
-      const match2 = compile(str(args[1]), caseMode(args, 3), false).exec(str(args[0]));
-      return match2 ? match2[0] : fail(ERR.NA);
+      const mode = optNum(args, 2, 0);
+      if (mode !== 0 && mode !== 1 && mode !== 2) fail(ERR.VALUE);
+      const regex = compile(str(args[1]), caseMode(args, 3), mode === 1);
+      const text2 = str(args[0]);
+      if (mode === 1) {
+        const matches2 = [];
+        for (const match3 of text2.matchAll(regex)) {
+          checkArraySize(matches2.length + 1, 1);
+          matches2.push(match3[0]);
+        }
+        return matches2.length ? new Matrix(matches2.map((match3) => [match3])) : fail(ERR.NA);
+      }
+      const match2 = regex.exec(text2);
+      if (!match2) fail(ERR.NA);
+      if (mode === 0) return match2[0];
+      if (match2.length === 1) fail(ERR.VALUE);
+      return new Matrix([match2.slice(1).map((group) => group ?? "")]);
     }
   ),
   spec(
@@ -11842,7 +11856,7 @@ function makeTemplate(formula, shape2) {
   }
   const { starts } = shape2;
   const slotted = starts.map(() => false);
-  const refs = /* @__PURE__ */ new Map();
+  const refs2 = /* @__PURE__ */ new Map();
   let run = 0;
   for (const token of tokens) {
     const end = token.start + token.text.length;
@@ -11856,9 +11870,9 @@ function makeTemplate(formula, shape2) {
     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 });
+    refs2.set(ref, count2 === 1 ? { start: at } : { start: at, end: at + 1 });
   }
-  return { formula, shape: shape2, ast, slotted, refs };
+  return { formula, shape: shape2, ast, slotted, refs: refs2 };
 }
 function rowsFor(t, formula, shape2) {
   if (!sameShape(t.formula, t.shape, formula, shape2)) return void 0;
@@ -11882,11 +11896,11 @@ function rowsFor(t, formula, shape2) {
   return rows2;
 }
 function shiftSpec(spec2, slots, rows2) {
-  const startRow = rows2[slots.start];
-  const endRow = slots.end === void 0 ? startRow : rows2[slots.end];
-  if (startRow === spec2.start.row && endRow === spec2.end.row) return spec2;
+  const startRow2 = rows2[slots.start];
+  const endRow = slots.end === void 0 ? startRow2 : rows2[slots.end];
+  if (startRow2 === 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 };
+  const start = { row: startRow2, 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 };
@@ -13619,12 +13633,14 @@ function structuredToA1(formula, target2) {
 
 // xml/namespaces.ts
 var NS = {
+  /** SpreadsheetML main. */
+  x: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
   /** SpreadsheetML 2009 extensions (`x14:conditionalFormatting`, `x14:dataBar`). */
   x14: "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"};
 function parseXml(xml, options = {}) {
-  const label2 = options.label ?? "OOXML";
+  const label3 = options.label ?? "OOXML";
   if (/<!DOCTYPE|<!ENTITY/i.test(xml))
-    throw new Error(`${label2} XML with DTD or entity declarations is not supported`);
+    throw new Error(`${label3} XML with DTD or entity declarations is not supported`);
   let parseError = "";
   let parsed;
   try {
@@ -13635,12 +13651,12 @@ function parseXml(xml, options = {}) {
     }).parseFromString(xml, "application/xml");
   } catch (error) {
     throw new Error(
-      `Invalid ${label2} XML: ${error instanceof Error ? error.message : String(error)}`,
+      `Invalid ${label3} XML: ${error instanceof Error ? error.message : String(error)}`,
       { cause: error }
     );
   }
   if (parseError || !parsed.documentElement)
-    throw new Error(`Invalid ${label2} XML: ${parseError || "missing root element"}`);
+    throw new Error(`Invalid ${label3} XML: ${parseError || "missing root element"}`);
   return parsed;
 }
 var buildXml = (node) => new XMLSerializer().serializeToString(node);
@@ -13716,6 +13732,315 @@ function descendants(root, local, ns) {
   return Array.from(root.getElementsByTagNameNS(ns, local));
 }
 
+// xlsx/edit/sparkline-ranges.ts
+function checkedSparklineRange(raw) {
+  const range2 = normalizeRange(raw);
+  for (const point of [range2.start, range2.end])
+    if (!Number.isInteger(point.row) || !Number.isInteger(point.col) || point.row < 0 || point.col < 0 || point.row > MAX_ROW || point.col > MAX_COL)
+      throw new RangeError("The reference is not valid.");
+  return range2;
+}
+function sparklineDataRange(workbook, sheet, source) {
+  let ast;
+  try {
+    ast = parseFormula(source.trim().replace(/^=/, ""));
+  } catch {
+    throw new Error("The reference is not valid.");
+  }
+  if (ast.type !== "ref" || !ast.ref || !["cell", "area"].includes(ast.ref.kind) || ast.prefix?.book || ast.prefix?.sheet2 || ast.spill)
+    throw new Error("The reference is not valid.");
+  const index2 = ast.prefix ? workbook.sheets.findIndex((ws) => ws.name.toLowerCase() === ast.prefix.sheet.toLowerCase()) : sheet;
+  if (!workbook.sheets[index2]) throw new Error("The reference is not valid.");
+  return { sheet: index2, range: checkedSparklineRange({ start: ast.ref.start, end: ast.ref.end }) };
+}
+function newSparklines(workbook, sheet, source, locations) {
+  const data = sparklineDataRange(workbook, sheet, source);
+  const dest = checkedSparklineRange(locations);
+  const rows2 = dest.end.row - dest.start.row + 1;
+  const cols = dest.end.col - dest.start.col + 1;
+  const dr = data.range.end.row - data.range.start.row + 1;
+  const dc = data.range.end.col - data.range.start.col + 1;
+  if (rows2 > 1 && cols > 1 || rows2 === 1 && cols === 1 && dr > 1 && dc > 1 || rows2 > 1 && rows2 !== dr || cols > 1 && cols !== dc)
+    throw new Error("The data range and location range do not match.");
+  if (Math.max(rows2, cols) > 1e5) throw new Error("The sparkline location range is too large.");
+  const prefix = `'${workbook.sheets[data.sheet].name.replaceAll("'", "''")}'!`;
+  const out = [];
+  for (let i2 = 0; i2 < Math.max(rows2, cols); i2++) {
+    const range2 = structuredClone(data.range);
+    if (rows2 > 1) range2.start.row = range2.end.row = data.range.start.row + i2;
+    if (cols > 1) range2.start.col = range2.end.col = data.range.start.col + i2;
+    const host = {
+      row: dest.start.row + (rows2 > 1 ? i2 : 0),
+      col: dest.start.col + (cols > 1 ? i2 : 0)
+    };
+    out.push({ formula: prefix + formatRange(range2), host: { start: host, end: { ...host } } });
+  }
+  return out;
+}
+
+// xlsx/pivot/data.ts
+var PIVOT_AGGREGATES = ["sum", "count", "average", "min", "max"];
+function pivotSourceData(workbook, sheet, source) {
+  const data = sparklineDataRange(workbook, sheet, source);
+  const ws = workbook.sheets[data.sheet];
+  const { start, end } = data.range;
+  if (end.row <= start.row || (end.row - start.row + 1) * (end.col - start.col + 1) > 1e6)
+    throw new Error("A PivotTable source needs headers and data, with at most one million cells.");
+  const fields = [];
+  for (let col = start.col; col <= end.col; col++) {
+    const value2 = getCell(ws, start.row, col)?.value;
+    if (value2 === void 0 || value2 === null || isCellError(value2) || !String(value2).trim())
+      throw new Error("Every PivotTable source column needs a unique, non-empty header.");
+    fields.push(String(value2));
+  }
+  if (new Set(fields.map((name) => name.toLowerCase())).size !== fields.length)
+    throw new Error("Every PivotTable source column needs a unique, non-empty header.");
+  const records = [];
+  for (let row2 = start.row + 1; row2 <= end.row; row2++) {
+    const record = [];
+    for (let col = start.col; col <= end.col; col++)
+      record.push(getCell(ws, row2, col)?.value ?? null);
+    records.push(record);
+  }
+  return { source: `${quoteSheetName(ws.name)}!${formatRange(data.range)}`, fields, records };
+}
+function pivotValueKey(value2) {
+  return value2 === null || value2 === "" ? "blank" : isCellError(value2) ? `error:${value2.error}` : `${typeof value2}:${String(value2).toLowerCase()}`;
+}
+function pivotItems(pivot, field) {
+  const index2 = pivot.fields.indexOf(field);
+  const items = /* @__PURE__ */ new Map();
+  for (const record of pivot.records) {
+    const value2 = record[index2] ?? null;
+    const key = pivotValueKey(value2);
+    if (!items.has(key)) items.set(key, value2);
+  }
+  const rank3 = (value2) => value2 === null || value2 === "" ? 4 : isCellError(value2) ? 3 : typeof value2 === "boolean" ? 2 : typeof value2 === "string" ? 1 : 0;
+  return [...items.values()].sort(
+    (a, b) => rank3(a) - rank3(b) || (typeof a === "number" && typeof b === "number" ? a - b : String(pivotItemLabel(a)).localeCompare(String(pivotItemLabel(b)), "en", {
+      sensitivity: "base",
+      numeric: true
+    }))
+  );
+}
+function pivotItemLabel(value2) {
+  if (value2 === null || value2 === "") return "(blank)";
+  if (typeof value2 === "boolean") return value2 ? "TRUE" : "FALSE";
+  return isCellError(value2) ? value2.error : value2;
+}
+function validatePivotFields(pivot) {
+  const used = [
+    pivot.rowField,
+    ...pivot.secondRowField ? [pivot.secondRowField] : [],
+    ...pivot.columnField ? [pivot.columnField] : [],
+    pivot.valueField
+  ];
+  if (pivot.layout !== void 0 && !["tabular", "compact", "outline"].includes(pivot.layout) || pivot.subtotalPosition !== void 0 && !["top", "bottom"].includes(pivot.subtotalPosition) || !PIVOT_AGGREGATES.includes(pivot.aggregate) || used.some((field) => !pivot.fields.includes(field)) || new Set([pivot.rowField, pivot.secondRowField, pivot.columnField].filter(Boolean)).size !== [pivot.rowField, pivot.secondRowField, pivot.columnField].filter(Boolean).length || pivot.subtotals !== void 0 && typeof pivot.subtotals !== "boolean" || pivot.repeatLabels !== void 0 && typeof pivot.repeatLabels !== "boolean")
+    throw new Error("Choose valid PivotTable fields; row and column fields must differ.");
+}
+function pivotCaption(aggregate3, field) {
+  return `${aggregate3[0].toUpperCase()}${aggregate3.slice(1)} of ${field}`;
+}
+
+// xlsx/pivot/hierarchy.ts
+var label2 = pivotItemLabel;
+function hierarchicalPivotGrid(pivot, aggregate3) {
+  const rowItems = pivotItems(pivot, pivot.rowField);
+  const secondRowItems = pivotItems(pivot, pivot.secondRowField);
+  const columnItems = pivot.columnField ? pivotItems(pivot, pivot.columnField) : [];
+  const outerField = pivot.fields.indexOf(pivot.rowField);
+  const innerField = pivot.fields.indexOf(pivot.secondRowField);
+  const columnField = pivot.columnField ? pivot.fields.indexOf(pivot.columnField) : -1;
+  const valueField = pivot.fields.indexOf(pivot.valueField);
+  const layout2 = pivot.layout ?? "tabular";
+  const compact3 = layout2 === "compact";
+  const top = layout2 !== "tabular" && pivot.subtotals !== false && (pivot.subtotalPosition ?? "top") === "top";
+  const bottom = pivot.subtotals !== false && !top;
+  const rowLabelColumns = compact3 ? 1 : 2;
+  const groups = /* @__PURE__ */ new Map();
+  const details = /* @__PURE__ */ new Map();
+  const children2 = /* @__PURE__ */ new Map();
+  const innerIndices = new Map(secondRowItems.map((item, index2) => [pivotValueKey(item), index2]));
+  const buckets = /* @__PURE__ */ new Map();
+  const collect = (map, key, record) => {
+    const list = map.get(key);
+    if (list) list.push(record);
+    else map.set(key, [record]);
+  };
+  for (const record of pivot.records) {
+    const outer = pivotValueKey(record[outerField] ?? null);
+    const inner2 = pivotValueKey(record[innerField] ?? null);
+    collect(groups, outer, record);
+    collect(details, JSON.stringify([outer, inner2]), record);
+    if (!children2.has(outer)) children2.set(outer, /* @__PURE__ */ new Set());
+    children2.get(outer).add(inner2);
+    if (pivot.columnField) {
+      const column = pivotValueKey(record[columnField] ?? null);
+      for (const key of [[], [outer], [outer, inner2]])
+        collect(buckets, JSON.stringify([...key, column]), record);
+    }
+  }
+  const rows2 = details.size + rowItems.length * (Number(layout2 !== "tabular") + Number(bottom)) + 3;
+  if (rows2 * (columnItems.length + 3) > 1e6)
+    throw new Error("The PivotTable result is too large.");
+  const labels = compact3 ? ["Row Labels"] : [pivot.rowField, pivot.secondRowField];
+  const values2 = pivot.columnField ? [
+    [
+      pivot.valueCaption,
+      ...compact3 ? [] : [null],
+      compact3 ? "Column Labels" : pivot.columnField,
+      ...columnItems.slice(1).map(() => null),
+      null
+    ],
+    [...labels, ...columnItems.map(label2), "Grand Total"]
+  ] : [[...labels, pivot.valueCaption]];
+  const indents = values2.map(() => 0);
+  const rowEntries = [];
+  const append = (labels2, numbers4, entry, indent = 0) => {
+    values2.push([...labels2, ...numbers4]);
+    rowEntries.push(entry);
+    indents.push(indent);
+  };
+  const numbers3 = (keys, records) => [
+    ...columnItems.map(
+      (column) => aggregate3(
+        buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+        valueField,
+        pivot.aggregate
+      )
+    ),
+    aggregate3(records, valueField, pivot.aggregate)
+  ];
+  rowItems.forEach((outer, outerIndex) => {
+    const key = pivotValueKey(outer);
+    if (layout2 !== "tabular")
+      append(
+        [label2(outer), ...compact3 ? [] : [null]],
+        top ? numbers3([key], groups.get(key) ?? []) : Array(columnItems.length + 1).fill(null),
+        { indices: [outerIndex] }
+      );
+    let first2 = true;
+    [...children2.get(key)].sort((a, b) => innerIndices.get(a) - innerIndices.get(b)).forEach((innerKey) => {
+      const innerIndex = innerIndices.get(innerKey);
+      const inner2 = secondRowItems[innerIndex];
+      const keys = [key, innerKey];
+      const records = details.get(JSON.stringify(keys));
+      if (!records) return;
+      append(
+        compact3 ? [label2(inner2)] : [
+          pivot.repeatLabels || layout2 === "tabular" && first2 ? label2(outer) : null,
+          label2(inner2)
+        ],
+        numbers3(keys, records),
+        { indices: [outerIndex, innerIndex] },
+        compact3 ? 1 : 0
+      );
+      first2 = false;
+    });
+    if (bottom) {
+      const caption = String(label2(outer));
+      append(
+        [`${caption} Total`, ...compact3 ? [] : [null]],
+        numbers3([key], groups.get(key) ?? []),
+        { indices: [outerIndex], type: "default" }
+      );
+    }
+  });
+  append(["Grand Total", ...compact3 ? [] : [null]], numbers3([], pivot.records), {
+    indices: [0],
+    type: "grand"
+  });
+  return {
+    values: values2,
+    rowItems,
+    secondRowItems,
+    columnItems,
+    rowEntries,
+    firstDataRow: pivot.columnField ? 2 : 1,
+    rowLabelColumns,
+    indents
+  };
+}
+
+// xlsx/pivot/aggregate.ts
+function aggregate2(records, field, type) {
+  if (!records.length) return null;
+  const values2 = records.map((record) => record[field] ?? null);
+  if (type === "count") return values2.filter((value2) => value2 !== null && value2 !== "").length;
+  const error = values2.find(isCellError);
+  if (error) return error;
+  const numbers3 = values2.filter((value2) => typeof value2 === "number");
+  if (!numbers3.length) return type === "average" ? { error: "#DIV/0!" } : 0;
+  if (type === "min") return numbers3.reduce((a, b) => Math.min(a, b));
+  if (type === "max") return numbers3.reduce((a, b) => Math.max(a, b));
+  const sum2 = numbers3.reduce((total2, value2) => total2 + value2, 0);
+  return type === "average" ? sum2 / numbers3.length : sum2;
+}
+function pivotGrid(pivot) {
+  validatePivotFields(pivot);
+  if (pivot.secondRowField) return hierarchicalPivotGrid(pivot, aggregate2);
+  const rowItems = pivotItems(pivot, pivot.rowField);
+  const columnItems = pivot.columnField ? pivotItems(pivot, pivot.columnField) : [];
+  if ((rowItems.length + 3) * (columnItems.length + 2) > 1e6)
+    throw new Error("The PivotTable result is too large.");
+  const rowField = pivot.fields.indexOf(pivot.rowField);
+  const colField = pivot.columnField ? pivot.fields.indexOf(pivot.columnField) : -1;
+  const valueField = pivot.fields.indexOf(pivot.valueField);
+  const groups = /* @__PURE__ */ new Map();
+  const cells = /* @__PURE__ */ new Map();
+  const columns = /* @__PURE__ */ new Map();
+  const collect = (map, key, record) => {
+    const found = map.get(key);
+    if (found) found.push(record);
+    else map.set(key, [record]);
+  };
+  for (const record of pivot.records) {
+    const key = pivotValueKey(record[rowField] ?? null);
+    collect(groups, key, record);
+    if (pivot.columnField) {
+      const col = pivotValueKey(record[colField] ?? null);
+      collect(columns, col, record);
+      collect(cells, JSON.stringify([key, col]), record);
+    }
+  }
+  const label3 = pivotItemLabel;
+  const values2 = pivot.columnField ? [
+    [
+      pivot.valueCaption,
+      pivot.layout === "compact" ? "Column Labels" : pivot.columnField,
+      ...columnItems.slice(1).map(() => null),
+      null
+    ],
+    [
+      pivot.layout === "compact" ? "Row Labels" : pivot.rowField,
+      ...columnItems.map(label3),
+      "Grand Total"
+    ]
+  ] : [[pivot.layout === "compact" ? "Row Labels" : pivot.rowField, pivot.valueCaption]];
+  for (const row2 of rowItems) {
+    const records = groups.get(pivotValueKey(row2)) ?? [];
+    values2.push([
+      label3(row2),
+      ...columnItems.map(
+        (col) => aggregate2(
+          cells.get(JSON.stringify([pivotValueKey(row2), pivotValueKey(col)])) ?? [],
+          valueField,
+          pivot.aggregate
+        )
+      ),
+      aggregate2(records, valueField, pivot.aggregate)
+    ]);
+  }
+  values2.push([
+    "Grand Total",
+    ...columnItems.map(
+      (col) => aggregate2(columns.get(pivotValueKey(col)) ?? [], valueField, pivot.aggregate)
+    ),
+    aggregate2(pivot.records, valueField, pivot.aggregate)
+  ]);
+  return { values: values2, rowItems, columnItems, firstDataRow: pivot.columnField ? 2 : 1 };
+}
+
 // xlsx/read/style-parts.ts
 function parseColor(element2, palette) {
   if (!element2) return void 0;
@@ -13749,6 +14074,23 @@ function parseSqref(sqref) {
   return sqref.split(/\s+/).filter(Boolean).map((part) => parseRange(part)).filter((range2) => range2 !== void 0);
 }
 
+// xlsx/write/xml-out.ts
+var CONTROL2 = "\0-\b\v\f-" + String.fromCharCode(65534, 65535);
+var INVALID_XML = new RegExp(`[${CONTROL2}]`, "g");
+var escapeText = (text2) => text2.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escapeAttr = (text2) => text2.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;").replace(/\t/g, "&#9;");
+function attrs(values2) {
+  let out = "";
+  for (const [name, value2] of Object.entries(values2)) {
+    if (value2 === void 0) continue;
+    const text2 = typeof value2 === "boolean" ? value2 ? "1" : "0" : typeof value2 === "number" ? num2(value2) : value2;
+    out += ` ${name}="${escapeAttr(text2)}"`;
+  }
+  return out;
+}
+var el = (name, values2 = {}, content = "") => content ? `<${name}${attrs(values2)}>${content}</${name}>` : `<${name}${attrs(values2)}/>`;
+var num2 = (value2) => Object.is(value2, -0) ? "0" : String(value2);
+
 // xlsx/conditional-extensions.ts
 var XM = "http://schemas.microsoft.com/office/excel/2006/main";
 function dataBarLengths(rule, node) {
@@ -14331,143 +14673,386 @@ function shiftFormulaInBand(formula, formulaSheet, sheet, shift2, band) {
   return changed ? tokens.map((t) => t.text).join("") : formula;
 }
 
-// xlsx/edit/context.ts
-function sheetAt(workbook, index2) {
-  const sheet = Number.isInteger(index2) ? workbook.sheets[index2] : void 0;
-  if (!sheet) throw new RangeError(`No sheet at index ${index2}`);
-  return sheet;
+// xlsx/write/style-xml.ts
+var argb = (rgb2) => (rgb2.length === 6 ? `FF${rgb2}` : rgb2).toUpperCase();
+function colorXml(color, name = "color") {
+  if (!color) return "";
+  if (color.rgb) return el(name, { rgb: argb(color.rgb), tint: color.tint });
+  if (color.theme !== void 0) return el(name, { theme: color.theme, tint: color.tint });
+  if (color.indexed !== void 0) return el(name, { indexed: color.indexed, tint: color.tint });
+  if (color.auto) return el(name, { auto: true });
+  return "";
 }
-function baseStyleId(sheet, row2, col) {
-  const rowStyle = sheet.rowInfo.get(row2)?.styleId;
-  if (rowStyle) return rowStyle;
-  const column = sheet.columns.find((c) => col >= c.min && col <= c.max);
-  return column?.styleId || void 0;
+
+// xlsx/layout/sparkline-view.ts
+var DEFAULTS = {
+  colorSeries: "#376092",
+  colorNegative: "#D00000",
+  colorAxis: "#000000",
+  colorMarkers: "#D00000",
+  colorFirst: "#D00000",
+  colorLast: "#D00000",
+  colorHigh: "#D00000",
+  colorLow: "#D00000"
+};
+var COLUMN_GAP = 0.2;
+function extent(values2) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const v of values2) {
+    if (v === null) continue;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  return min <= max ? { min, max } : void 0;
 }
-function ensureCell(sheet, row2, col) {
-  const existing = getCell(sheet, row2, col);
-  if (existing) return existing;
-  const cell = { value: null };
-  const styleId = baseStyleId(sheet, row2, col);
-  if (styleId) cell.styleId = styleId;
-  putCell(sheet, row2, col, cell);
-  return cell;
+function sparklineValues(group, values2) {
+  return group.displayEmptyCellsAs === "zero" ? values2.map((v) => v ?? 0) : [...values2];
 }
-var isWholeColumns = (range2) => range2.start.row === 0 && range2.end.row >= MAX_ROW;
-var isWholeRows = (range2) => range2.start.col === 0 && range2.end.col >= MAX_COL;
-function clipToUsed(sheet, range2) {
-  const r = normalizeRange(range2);
-  const used = usedRange(sheet);
-  if (!used) return void 0;
-  const start = {
-    row: Math.max(r.start.row, used.start.row),
-    col: Math.max(r.start.col, used.start.col)
+function sparklineScale(group, all2, index2) {
+  const own = extent(sparklineValues(group, all2[index2]?.values ?? []));
+  const needsGroup = group.minAxisType === "group" || group.maxAxisType === "group";
+  const shared = needsGroup ? extent(all2.flatMap((data) => sparklineValues(group, data.values))) : void 0;
+  const end = (type, manual, key) => {
+    if (type === "custom" && manual !== void 0) return manual;
+    if (type === "group" && shared) return shared[key];
+    return own?.[key];
   };
-  const end = { row: Math.min(r.end.row, used.end.row), col: Math.min(r.end.col, used.end.col) };
-  return start.row > end.row || start.col > end.col ? void 0 : { start, end };
-}
-var DENSE_LIMIT = 25e4;
-function forEachPosition(sheet, range2, visit2) {
-  let r = normalizeRange(range2);
-  const size = (r.end.row - r.start.row + 1) * (r.end.col - r.start.col + 1);
-  if (size > DENSE_LIMIT) r = clipToUsed(sheet, r);
-  if (!r) return;
-  for (let row2 = r.start.row; row2 <= r.end.row; row2++)
-    for (let col = r.start.col; col <= r.end.col; col++) visit2(row2, col);
-}
-function rawText(value2) {
-  if (value2 === null) return "";
-  if (isCellError(value2)) return value2.error;
-  if (typeof value2 === "boolean") return value2 ? "TRUE" : "FALSE";
-  return String(value2);
-}
-function pruneCell(sheet, row2, col) {
-  const cell = getCell(sheet, row2, col);
-  if (!cell) return;
-  if (cell.value === null && cell.formula === void 0 && !cell.styleId && !cell.richText) {
-    const cells = sheet.rows.get(row2);
-    cells?.delete(col);
-    if (cells && cells.size === 0) sheet.rows.delete(row2);
-  }
+  const min = end(group.minAxisType, group.manualMin, "min");
+  const max = end(group.maxAxisType, group.manualMax, "max");
+  return min === void 0 || max === void 0 ? void 0 : { min, max };
 }
-
-// xlsx/edit/shift-preserved.ts
-var XM3 = "http://schemas.microsoft.com/office/excel/2006/main";
-function hasPreservedOverflow(sheet, shift2, clipped, banded) {
-  const keys = banded ? ["extLst"] : [shift2.axis === "row" ? "rowBreaks" : "colBreaks", "extLst"];
-  for (const key of keys)
-    for (const xml of sheet.preserved.get(key) ?? []) {
-      if (!xml.includes(key === "extLst" ? "sqref" : "brk")) continue;
-      let root;
-      try {
-        root = parseXml(xml).documentElement;
-      } catch {
-        continue;
-      }
-      if (key === "extLst") {
-        if (descendants2(root, XM3, "sqref").some(
-          (node) => parseSqref(node.textContent ?? "").some(clipped)
-        ))
-          return true;
-      } else if (elements(root).some(
-        (node) => node.localName === "brk" && shiftIndex(Number(node.getAttribute("id") ?? "0"), shift2) === void 0
-      ))
-        return true;
+function positions(group, data, n) {
+  const dates = data.dates;
+  if (group.dateAxis && dates && dates.length === n) {
+    const span4 = extent(dates);
+    if (span4) {
+      const width = span4.max - span4.min;
+      return dates.map((d) => d === null ? null : width ? (d - span4.min) / width : 0.5);
     }
-  return false;
+  }
+  if (group.dateAxis) return Array.from({ length: n }, () => null);
+  return Array.from({ length: n }, (_, i2) => n === 1 ? 0.5 : i2 / (n - 1));
 }
-function descendants2(root, ns, local) {
-  return Array.from(root.getElementsByTagNameNS(ns, local));
+function pointFacts(values2) {
+  const numbers3 = values2.filter((x) => x !== null);
+  let last = values2.length - 1;
+  while (last >= 0 && values2[last] === null) last--;
+  return {
+    high: Math.max(...numbers3),
+    low: Math.min(...numbers3),
+    first: values2.findIndex((x) => x !== null),
+    last
+  };
 }
-function editEntries(sheet, key, edit, quick) {
-  const list = sheet.preserved.get(key);
-  if (!list) return;
-  const next = [];
-  for (const xml of list) {
-    if (!quick(xml)) {
-      next.push(xml);
-      continue;
-    }
-    let doc;
-    try {
-      doc = parseXml(xml);
-    } catch {
-      next.push(xml);
-      continue;
-    }
-    const outcome = edit(doc.documentElement);
-    if (outcome === "same") next.push(xml);
-    else if (outcome === "changed") next.push(buildXml(doc));
-  }
-  if (next.length) sheet.preserved.set(key, next);
-  else sheet.preserved.delete(key);
+function pointColor(group, v, i2, facts, colors, markers) {
+  let color = markers && group.markers ? colors.colorMarkers : void 0;
+  if (group.negative && v < 0) color = colors.colorNegative;
+  if (group.high && v === facts.high) color = colors.colorHigh;
+  if (group.low && v === facts.low) color = colors.colorLow;
+  if (group.first && i2 === facts.first) color = colors.colorFirst;
+  if (group.last && i2 === facts.last) color = colors.colorLast;
+  return color;
 }
-function shiftBreaks(root, shift2) {
-  let changed = false;
-  for (const brk of elements(root).filter((e) => e.localName === "brk")) {
-    const id = Number(brk.getAttribute("id") ?? "0");
-    const moved = shiftIndex(id, shift2);
-    if (moved === id) continue;
-    changed = true;
-    if (moved === void 0 || moved === 0) root.removeChild(brk);
-    else brk.setAttribute("id", String(moved));
-  }
-  if (!changed) return "same";
-  const left2 = elements(root).filter((e) => e.localName === "brk");
-  if (!left2.length) return "drop";
-  if (root.hasAttribute("count")) root.setAttribute("count", String(left2.length));
-  if (root.hasAttribute("manualBreakCount")) {
-    const manual = left2.filter((b) => /^(1|true)$/.test(b.getAttribute("man") ?? "")).length;
-    root.setAttribute("manualBreakCount", String(manual));
+function resolveColors(group, theme2) {
+  const out = { ...DEFAULTS };
+  for (const key of Object.keys(DEFAULTS)) {
+    const color = group[key];
+    out[key] = resolveColor(color, theme2, DEFAULTS[key]) ?? DEFAULTS[key];
   }
-  return "changed";
+  return out;
 }
-function removeUpwards(node, root) {
-  let current = node;
-  while (current && current !== root) {
-    const parent = current.parentNode;
-    parent?.removeChild(current);
-    if (!parent) break;
-    const emptied = elements(parent).length === 0 || parent.localName === "sparklineGroup" && !elements(parent).some((e) => e.localName === "sparklines");
+function sparklineView(group, data, scale2, theme2) {
+  const colors = resolveColors(group, theme2);
+  const view = {
+    type: group.type,
+    color: colors.colorSeries,
+    lineWeightPt: group.lineWeight,
+    lines: [],
+    markers: [],
+    columns: []
+  };
+  const values2 = sparklineValues(group, data.values);
+  const n = values2.length;
+  if (!n || !scale2) return view;
+  const facts = pointFacts(values2);
+  const xs = positions(group, data, n);
+  const flip = (x) => group.rightToLeft ? 1 - x : x;
+  const range2 = scale2.max - scale2.min;
+  const yOf = (v) => range2 ? Math.max(0, Math.min(1, (scale2.max - v) / range2)) : 0.5;
+  if (group.type === "line") {
+    let segment = [];
+    values2.forEach((v, i2) => {
+      const x = xs[i2];
+      if (v === null || x === null || x === void 0) {
+        if (group.displayEmptyCellsAs === "gap" && segment.length) {
+          view.lines.push(segment);
+          segment = [];
+        }
+        return;
+      }
+      const point = { x: flip(x), y: yOf(v) };
+      segment.push(point);
+      const color = pointColor(group, v, i2, facts, colors, true);
+      if (color) view.markers.push({ ...point, color });
+    });
+    if (segment.length) view.lines.push(segment);
+  } else {
+    const dates = group.dateAxis && data.dates ? extent(data.dates) : void 0;
+    const slot = dates ? 1 / Math.max(1, dates.max - dates.min + 1) : 1 / n;
+    const w = slot * (1 - COLUMN_GAP);
+    const base = yOf(Math.max(scale2.min, Math.min(scale2.max, 0)));
+    values2.forEach((v, i2) => {
+      const position = xs[i2];
+      if (v === null || position === null || position === void 0) return;
+      if (v === 0) return;
+      let top;
+      let bottom;
+      if (group.type === "stacked") [top, bottom] = v > 0 ? [0, 0.5] : [0.5, 1];
+      else if (!range2) [top, bottom] = [0, 1];
+      else [top, bottom] = [Math.min(base, yOf(v)), Math.max(base, yOf(v))];
+      const centre = flip(slot / 2 + position * (1 - slot));
+      const color = pointColor(group, v, i2, facts, colors, false) ?? view.color;
+      view.columns.push({ x: centre - w / 2, y: top, w, h: bottom - top, color });
+    });
+  }
+  if (group.type === "stacked") {
+    if (group.displayXAxis) view.axis = { y: 0.5, color: colors.colorAxis };
+  } else if (group.displayXAxis && range2 && scale2.min <= 0 && scale2.max >= 0)
+    view.axis = { y: yOf(0), color: colors.colorAxis };
+  return view;
+}
+
+// xlsx/layout/sparkline-data.ts
+var MAX_POINTS = 1e4;
+var hostIndex = /* @__PURE__ */ new WeakMap();
+function hosts(sheet) {
+  const groups = sheetSparklineGroups(sheet);
+  let index2 = hostIndex.get(groups);
+  if (!index2) {
+    index2 = /* @__PURE__ */ new Map();
+    for (const group of groups)
+      group.sparklines.forEach((line2, i2) => {
+        const key = cellKey(line2.host.start.row, line2.host.start.col);
+        if (!index2.has(key)) index2.set(key, { group, index: i2 });
+      });
+    hostIndex.set(groups, index2);
+  }
+  return index2;
+}
+function hasSparklineAt(sheet, row2, col) {
+  return hosts(sheet).has(cellKey(row2, col));
+}
+function resolveSparklineRange(workbook, sheet, formula) {
+  const ref = formula.trim().replace(/^=/, "");
+  const bang = ref.lastIndexOf("!");
+  let target2 = sheet;
+  if (bang >= 0) {
+    const raw = ref.slice(0, bang);
+    const name = /^'.*'$/.test(raw) ? raw.slice(1, -1).replace(/''/g, "'") : raw;
+    target2 = sheetByName(workbook, name);
+  }
+  const range2 = parseRange(ref.slice(bang + 1).replace(/\$/g, ""));
+  return target2 && range2 ? { sheet: target2, range: normalizeRange(range2) } : void 0;
+}
+var rowHidden = (sheet, row2) => sheet.rowInfo.get(row2)?.hidden === true;
+var colHidden = (sheet, col) => sheet.columns.some((c) => c.hidden === true && col >= c.min && col <= c.max);
+function readSparklineValues(sheet, range2, displayHidden) {
+  let endRow = range2.end.row;
+  if (endRow - range2.start.row >= MAX_POINTS) {
+    let lastRow = range2.start.row;
+    for (const row2 of sheet.rows.keys()) if (row2 > lastRow) lastRow = row2;
+    endRow = Math.min(endRow, lastRow);
+  }
+  const out = [];
+  for (let row2 = range2.start.row; row2 <= endRow && out.length < MAX_POINTS; row2++) {
+    if (!displayHidden && rowHidden(sheet, row2)) continue;
+    for (let col = range2.start.col; col <= range2.end.col && out.length < MAX_POINTS; col++) {
+      if (!displayHidden && colHidden(sheet, col)) continue;
+      const value2 = getCell(sheet, row2, col)?.value;
+      out.push(typeof value2 === "number" && Number.isFinite(value2) ? value2 : null);
+    }
+  }
+  return out;
+}
+function groupData(workbook, sheet, group) {
+  const dateRange = group.dateAxis && group.dateFormula;
+  const dates = dateRange ? resolveSparklineRange(workbook, sheet, dateRange) : void 0;
+  const dateValues = dates ? readSparklineValues(dates.sheet, dates.range, true) : void 0;
+  return group.sparklines.map((line2) => {
+    const source = line2.formula ? resolveSparklineRange(workbook, sheet, line2.formula) : void 0;
+    if (group.dateAxis) {
+      if (!source || !dates || !dateValues) return { values: [], dates: [] };
+      const raw = readSparklineValues(source.sheet, source.range, true);
+      if (raw.length !== dateValues.length) return { values: [], dates: [] };
+      const hidden = (ref, i2) => {
+        const columns = ref.range.end.col - ref.range.start.col + 1;
+        return rowHidden(ref.sheet, ref.range.start.row + Math.floor(i2 / columns)) || colHidden(ref.sheet, ref.range.start.col + i2 % columns);
+      };
+      const pairs = dateValues.flatMap(
+        (date, i2) => date === null || !group.displayHidden && (hidden(source, i2) || hidden(dates, i2)) ? [] : [{ date, value: raw[i2] }]
+      );
+      pairs.sort((a, b) => a.date - b.date);
+      return { values: pairs.map((pair) => pair.value), dates: pairs.map((pair) => pair.date) };
+    }
+    const values2 = source ? readSparklineValues(source.sheet, source.range, group.displayHidden) : [];
+    return { values: values2 };
+  });
+}
+function sparklineViewAt(workbook, sheetIndex2, row2, col) {
+  const sheet = workbook.sheets[sheetIndex2];
+  if (!sheet) return void 0;
+  const entry = hosts(sheet).get(cellKey(row2, col));
+  if (!entry) return void 0;
+  const { group, index: index2 } = entry;
+  const needsGroup = group.minAxisType === "group" || group.maxAxisType === "group";
+  const data = needsGroup ? groupData(workbook, sheet, group) : groupData(workbook, sheet, { ...group, sparklines: [group.sparklines[index2]] });
+  const at = needsGroup ? index2 : 0;
+  return sparklineView(
+    group,
+    data[at] ?? { values: [] },
+    sparklineScale(group, data, at),
+    workbook.theme
+  );
+}
+
+// xlsx/edit/context.ts
+function sheetAt(workbook, index2) {
+  const sheet = Number.isInteger(index2) ? workbook.sheets[index2] : void 0;
+  if (!sheet) throw new RangeError(`No sheet at index ${index2}`);
+  return sheet;
+}
+function baseStyleId(sheet, row2, col) {
+  const rowStyle = sheet.rowInfo.get(row2)?.styleId;
+  if (rowStyle) return rowStyle;
+  const column = sheet.columns.find((c) => col >= c.min && col <= c.max);
+  return column?.styleId || void 0;
+}
+function ensureCell(sheet, row2, col) {
+  const existing = getCell(sheet, row2, col);
+  if (existing) return existing;
+  const cell = { value: null };
+  const styleId = baseStyleId(sheet, row2, col);
+  if (styleId) cell.styleId = styleId;
+  putCell(sheet, row2, col, cell);
+  return cell;
+}
+var isWholeColumns = (range2) => range2.start.row === 0 && range2.end.row >= MAX_ROW;
+var isWholeRows = (range2) => range2.start.col === 0 && range2.end.col >= MAX_COL;
+function clipToUsed(sheet, range2) {
+  const r = normalizeRange(range2);
+  const used = usedRange(sheet);
+  if (!used) return void 0;
+  const start = {
+    row: Math.max(r.start.row, used.start.row),
+    col: Math.max(r.start.col, used.start.col)
+  };
+  const end = { row: Math.min(r.end.row, used.end.row), col: Math.min(r.end.col, used.end.col) };
+  return start.row > end.row || start.col > end.col ? void 0 : { start, end };
+}
+var DENSE_LIMIT = 25e4;
+function forEachPosition(sheet, range2, visit2) {
+  let r = normalizeRange(range2);
+  const size = (r.end.row - r.start.row + 1) * (r.end.col - r.start.col + 1);
+  if (size > DENSE_LIMIT) r = clipToUsed(sheet, r);
+  if (!r) return;
+  for (let row2 = r.start.row; row2 <= r.end.row; row2++)
+    for (let col = r.start.col; col <= r.end.col; col++) visit2(row2, col);
+}
+function rawText(value2) {
+  if (value2 === null) return "";
+  if (isCellError(value2)) return value2.error;
+  if (typeof value2 === "boolean") return value2 ? "TRUE" : "FALSE";
+  return String(value2);
+}
+function pruneCell(sheet, row2, col) {
+  const cell = getCell(sheet, row2, col);
+  if (!cell) return;
+  if (cell.value === null && cell.formula === void 0 && !cell.styleId && !cell.richText) {
+    const cells = sheet.rows.get(row2);
+    cells?.delete(col);
+    if (cells && cells.size === 0) sheet.rows.delete(row2);
+  }
+}
+
+// xlsx/edit/shift-preserved.ts
+var XM3 = "http://schemas.microsoft.com/office/excel/2006/main";
+function hasPreservedOverflow(sheet, shift2, clipped, banded) {
+  const keys = banded ? ["extLst"] : [shift2.axis === "row" ? "rowBreaks" : "colBreaks", "extLst"];
+  for (const key of keys)
+    for (const xml of sheet.preserved.get(key) ?? []) {
+      if (!xml.includes(key === "extLst" ? "sqref" : "brk")) continue;
+      let root;
+      try {
+        root = parseXml(xml).documentElement;
+      } catch {
+        continue;
+      }
+      if (key === "extLst") {
+        if (descendants2(root, XM3, "sqref").some(
+          (node) => parseSqref(node.textContent ?? "").some(clipped)
+        ))
+          return true;
+      } else if (elements(root).some(
+        (node) => node.localName === "brk" && shiftIndex(Number(node.getAttribute("id") ?? "0"), shift2) === void 0
+      ))
+        return true;
+    }
+  return false;
+}
+function descendants2(root, ns, local) {
+  return Array.from(root.getElementsByTagNameNS(ns, local));
+}
+function editEntries(sheet, key, edit, quick) {
+  const list = sheet.preserved.get(key);
+  if (!list) return;
+  const next = [];
+  for (const xml of list) {
+    if (!quick(xml)) {
+      next.push(xml);
+      continue;
+    }
+    let doc;
+    try {
+      doc = parseXml(xml);
+    } catch {
+      next.push(xml);
+      continue;
+    }
+    const outcome = edit(doc.documentElement);
+    if (outcome === "same") next.push(xml);
+    else if (outcome === "changed") next.push(buildXml(doc));
+  }
+  if (next.length) sheet.preserved.set(key, next);
+  else sheet.preserved.delete(key);
+}
+function shiftBreaks(root, shift2) {
+  let changed = false;
+  for (const brk of elements(root).filter((e) => e.localName === "brk")) {
+    const id = Number(brk.getAttribute("id") ?? "0");
+    const moved = shiftIndex(id, shift2);
+    if (moved === id) continue;
+    changed = true;
+    if (moved === void 0 || moved === 0) root.removeChild(brk);
+    else brk.setAttribute("id", String(moved));
+  }
+  if (!changed) return "same";
+  const left2 = elements(root).filter((e) => e.localName === "brk");
+  if (!left2.length) return "drop";
+  if (root.hasAttribute("count")) root.setAttribute("count", String(left2.length));
+  if (root.hasAttribute("manualBreakCount")) {
+    const manual = left2.filter((b) => /^(1|true)$/.test(b.getAttribute("man") ?? "")).length;
+    root.setAttribute("manualBreakCount", String(manual));
+  }
+  return "changed";
+}
+function removeUpwards(node, root) {
+  let current = node;
+  while (current && current !== root) {
+    const parent = current.parentNode;
+    parent?.removeChild(current);
+    if (!parent) break;
+    const emptied = elements(parent).length === 0 || parent.localName === "sparklineGroup" && !elements(parent).some((e) => e.localName === "sparklines");
     if (!emptied) break;
     current = parent;
   }
@@ -14577,6 +15162,13 @@ function rewriteFormulas(workbook, rewrite, formulaCells) {
 }
 function rewriteSheetFormulas(sheet, rewrite, formulaCells) {
   rewritePreservedFormulas(sheet, rewrite);
+  for (const pivot of sheet.pivotTables ?? []) {
+    const next = safe(rewrite, pivot.source, sheet.name);
+    if (next !== pivot.source) {
+      pivot.source = next;
+      pivot.dirty = true;
+    }
+  }
   {
     const name = sheet.name;
     for (const table2 of sheet.tables)
@@ -14929,20 +15521,20 @@ function addRowIntersections(sheet, r, patcher) {
 }
 
 // xlsx/edit/format.ts
-function stylePatcher(workbook, patch) {
+function stylePatcher(workbook, patch2) {
   const memo = /* @__PURE__ */ new Map();
   return (id) => {
     const key = id ?? 0;
     let next = memo.get(key);
     if (next === void 0) {
-      next = applyStylePatch(workbook, id, patch);
+      next = applyStylePatch(workbook, id, patch2);
       memo.set(key, next);
     }
     return next;
   };
 }
-function patchRange(workbook, sheet, range2, patch) {
-  patchRangeWith(sheet, range2, stylePatcher(workbook, patch));
+function patchRange(workbook, sheet, range2, patch2) {
+  patchRangeWith(sheet, range2, stylePatcher(workbook, patch2));
 }
 function patchRangeWith(sheet, range2, patcher) {
   const r = normalizeRange(range2);
@@ -14987,11 +15579,11 @@ function formatScopes(index2, ranges) {
   const whole = ranges.some((r) => isWholeColumns(r) || isWholeRows(r));
   return whole ? [cells, { kind: "parts", sheet: index2, parts: ["columns", "rowInfo"] }] : [cells];
 }
-function applyStyle(ctx, s, ranges, patch) {
+function applyStyle(ctx, s, ranges, patch2) {
   const sheet = sheetAt(ctx.workbook, s);
   const normalized = ranges.map(normalizeRange);
   if (!normalized.length) return;
-  const patcher = stylePatcher(ctx.workbook, patch);
+  const patcher = stylePatcher(ctx.workbook, patch2);
   ctx.run(
     "Format cells",
     "format",
@@ -15042,13 +15634,13 @@ function linearTrend(values2) {
   const n = values2.length;
   const meanX = (n - 1) / 2;
   const meanY = values2.reduce((a, b) => a + b, 0) / n;
-  let num2 = 0;
+  let num3 = 0;
   let den = 0;
   values2.forEach((y, x) => {
-    num2 += (x - meanX) * (y - meanY);
+    num3 += (x - meanX) * (y - meanY);
     den += (x - meanX) ** 2;
   });
-  const slope = den ? num2 / den : 0;
+  const slope = den ? num3 / den : 0;
   return (k) => Number((meanY + slope * (k - meanX)).toPrecision(15));
 }
 var isDigit5 = (ch) => ch !== void 0 && ch >= "0" && ch <= "9";
@@ -15651,6 +16243,17 @@ function setBorders(ctx, s, range2, preset, edge = { style: "thin" }) {
 
 // xlsx/edit/insert-guard.ts
 function assertInsertFits(sheet, shift2, band) {
+  for (const pivot of sheet.pivotTables ?? []) {
+    const start = pivot.location.start[shift2.axis];
+    const end = pivot.location.end[shift2.axis];
+    const other2 = shift2.axis === "row" ? "col" : "row";
+    if (band && (band.hi < pivot.location.start[other2] || band.lo > pivot.location.end[other2]))
+      continue;
+    const partial = band && (band.lo > pivot.location.start[other2] || band.hi < pivot.location.end[other2]);
+    const overlap = shift2.count > 0 ? shift2.at > start && shift2.at <= end : shift2.at <= end && shift2.at - shift2.count > start;
+    if (overlap || partial && shift2.at <= end)
+      throw new Error("Cannot move or remove part of a PivotTable. Delete the PivotTable first.");
+  }
   if (shift2.count <= 0) return;
   const max = shift2.axis === "row" ? MAX_ROW : MAX_COL;
   if (shift2.at + shift2.count > max + 1)
@@ -15718,6 +16321,13 @@ function shiftSheetContent(sheet, shift2, band) {
     return range2 ? [{ ...c, address: range2.start }] : [];
   });
   sheet.tables = sheet.tables.flatMap((t) => shiftTable(sheet, t, shift2, moveRange));
+  for (const pivot of sheet.pivotTables ?? []) {
+    const location = moveRange(pivot.location);
+    if (location) {
+      pivot.location = location;
+      pivot.dirty = true;
+    }
+  }
   for (const drawing of sheet.drawings) shiftAnchor(drawing.anchor, shift2, band);
   if (!band) shiftAxisFormats(sheet, shift2);
   if (sheet.autoFilter) {
@@ -15960,13 +16570,13 @@ function htmlHref(link) {
   const href = link?.target ? `${link.target}${link.location ? `#${link.location}` : ""}` : link?.location ? `#${link.location}` : void 0;
   return href && (href.startsWith("#") || hyperlinkPolicy(href).store) ? href : void 0;
 }
-function hyperlinkFromHtmlAttributes(attrs, range2) {
-  const href = attrs?.get("href");
+function hyperlinkFromHtmlAttributes(attrs2, range2) {
+  const href = attrs2?.get("href");
   if (!href || !href.startsWith("#") && !hyperlinkPolicy(href).store) return void 0;
   const link = { range: range2 };
   if (href.startsWith("#")) link.location = href.slice(1);
   else link.target = href;
-  const tooltip = attrs?.get("title");
+  const tooltip = attrs2?.get("title");
   if (tooltip) link.tooltip = tooltip;
   return link;
 }
@@ -16063,21 +16673,21 @@ function toHtml(cells, theme2) {
     for (let c = 0; c < cells.cols; c++) {
       if (covered.has(`${r},${c}`)) continue;
       const cell = cells.data[r]?.[c] ?? null;
-      const attrs = [];
+      const attrs2 = [];
       const span4 = spans2.get(`${r},${c}`);
       if (span4 && span4.end.row > span4.start.row)
-        attrs.push(`rowspan="${span4.end.row - span4.start.row + 1}"`);
+        attrs2.push(`rowspan="${span4.end.row - span4.start.row + 1}"`);
       if (span4 && span4.end.col > span4.start.col)
-        attrs.push(`colspan="${span4.end.col - span4.start.col + 1}"`);
-      if (cell && typeof cell.value === "number") attrs.push(`x:num="${cell.value}"`);
+        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) attrs.push(`style="${escapeHtml(css)}"`);
+      if (css) attrs2.push(`style="${escapeHtml(css)}"`);
       let text2 = escapeHtml(cell?.text ?? "").replace(/\n/g, "<br>");
       const link = links.get(`${r},${c}`);
       const href = htmlHref(link);
       if (href)
         text2 = `<a href="${escapeHtml(href)}"${link?.tooltip ? ` title="${escapeHtml(link.tooltip)}"` : ""}>${text2}</a>`;
-      tds.push(`<td${attrs.length ? ` ${attrs.join(" ")}` : ""}>${text2}</td>`);
+      tds.push(`<td${attrs2.length ? ` ${attrs2.join(" ")}` : ""}>${text2}</td>`);
     }
     rows2.push(`<tr>${tds.join("")}</tr>`);
   }
@@ -16137,12 +16747,12 @@ function decodeEntities(text2) {
   });
 }
 function parseAttributes(text2) {
-  const attrs = /* @__PURE__ */ new Map();
+  const attrs2 = /* @__PURE__ */ new Map();
   for (const m of text2.matchAll(
     /([\w:-]{1,64})\s{0,16}=\s{0,16}(?:"([^"]*)"|'([^']*)'|([^\s>]+))/g
   ))
-    attrs.set((m[1] ?? "").toLowerCase(), decodeEntities(m[2] ?? m[3] ?? m[4] ?? ""));
-  return attrs;
+    attrs2.set((m[1] ?? "").toLowerCase(), decodeEntities(m[2] ?? m[3] ?? m[4] ?? ""));
+  return attrs2;
 }
 function parseCss(text2) {
   const out = /* @__PURE__ */ new Map();
@@ -16168,7 +16778,7 @@ var V_ALIGN = {
   bottom: "bottom"
 };
 function stylePatchFromCss(css, inner2) {
-  const patch = {};
+  const patch2 = {};
   const font = {};
   const weight = css.get("font-weight");
   if (weight && (weight === "bold" || Number(weight) >= 600) || /<(b|strong)\b/i.test(inner2))
@@ -16184,16 +16794,16 @@ function stylePatchFromCss(css, inner2) {
   if (size) font.size = Number(size[1]) * (size[2] === "px" ? 0.75 : 1);
   const family = css.get("font-family")?.split(",")[0]?.trim().replace(/^["']|["']$/g, "");
   if (family) font.name = family;
-  if (Object.keys(font).length) patch.font = font;
+  if (Object.keys(font).length) patch2.font = font;
   const background = css.get("background-color") ?? css.get("background");
   const fill = background && parseCssColor(background.split(/\s+/)[0] ?? "");
-  if (fill) patch.fill = { type: "pattern", pattern: "solid", fgColor: fill };
+  if (fill) patch2.fill = { type: "pattern", pattern: "solid", fgColor: fill };
   const h2 = H_ALIGN[css.get("text-align") ?? ""];
   const v = V_ALIGN[css.get("vertical-align") ?? ""];
-  if (h2 || v) patch.alignment = { ...h2 ? { horizontal: h2 } : {}, ...v ? { vertical: v } : {} };
+  if (h2 || v) patch2.alignment = { ...h2 ? { horizontal: h2 } : {}, ...v ? { vertical: v } : {} };
   const numFmt = css.get("mso-number-format");
-  if (numFmt) patch.numFmt = decodeNumberFormat(numFmt);
-  return patch;
+  if (numFmt) patch2.numFmt = decodeNumberFormat(numFmt);
+  return patch2;
 }
 function removeComments(text2) {
   let out = "";
@@ -16268,18 +16878,18 @@ function parseHtmlTable(html, base) {
       /<t([dh])\b([^>]*)>([\s\S]*?)(?:<\/t[dh]>|(?=<t[dh]\b)|$)/gi
     )) {
       while (taken.has(`${r},${c}`)) c++;
-      const attrs = parseAttributes(td[2] ?? "");
+      const attrs2 = parseAttributes(td[2] ?? "");
       const inner2 = td[3] ?? "";
       const css = /* @__PURE__ */ new Map();
-      for (const name of (attrs.get("class") ?? "").split(/\s+/))
+      for (const name of (attrs2.get("class") ?? "").split(/\s+/))
         for (const [k, v] of parseCss(classes.get(name) ?? "")) css.set(k, v);
-      for (const [k, v] of parseCss(attrs.get("style") ?? "")) css.set(k, v);
-      const patch = stylePatchFromCss(css, inner2);
-      if (td[1]?.toLowerCase() === "h") patch.font = { bold: true, ...patch.font };
+      for (const [k, v] of parseCss(attrs2.get("style") ?? "")) css.set(k, v);
+      const patch2 = stylePatchFromCss(css, inner2);
+      if (td[1]?.toLowerCase() === "h") patch2.font = { bold: true, ...patch2.font };
       const text2 = cellText(inner2);
-      row2[c] = text2 === "" && !Object.keys(patch).length ? null : toCell(text2, attrs, patch, base);
-      const rowSpan = Math.max(1, Number(attrs.get("rowspan") ?? 1) || 1);
-      const colSpan = Math.max(1, Number(attrs.get("colspan") ?? 1) || 1);
+      row2[c] = text2 === "" && !Object.keys(patch2).length ? null : toCell(text2, attrs2, patch2, base);
+      const rowSpan = Math.max(1, Number(attrs2.get("rowspan") ?? 1) || 1);
+      const colSpan = Math.max(1, Number(attrs2.get("colspan") ?? 1) || 1);
       const anchor = /<a\b([^>]*)>/i.exec(inner2);
       const linkAttrs = anchor ? parseAttributes(anchor[1] ?? "") : void 0;
       const link = hyperlinkFromHtmlAttributes(linkAttrs, {
@@ -16309,17 +16919,17 @@ function parseHtmlTable(html, base) {
   );
   return rows2 && cols ? { rows: rows2, cols, data, merges, hyperlinks } : void 0;
 }
-function toCell(text2, attrs, patch, base) {
+function toCell(text2, attrs2, patch2, base) {
   let value2 = text2;
-  const num2 = attrs.get("x:num");
-  if (num2 !== void 0 && num2 !== "" && Number.isFinite(Number(num2))) value2 = Number(num2);
-  else if (attrs.has("x:bool")) value2 = text2.toUpperCase() === "TRUE";
-  else if (patch.numFmt !== "@" && text2 !== "") {
+  const num3 = attrs2.get("x:num");
+  if (num3 !== void 0 && num3 !== "" && Number.isFinite(Number(num3))) value2 = Number(num3);
+  else if (attrs2.has("x:bool")) value2 = text2.toUpperCase() === "TRUE";
+  else if (patch2.numFmt !== "@" && text2 !== "") {
     const parsed = parseCellInput(text2);
     if (parsed.formula === void 0) value2 = parsed.value;
-    if (!patch.numFmt && parsed.numFmt && typeof value2 === "number") patch.numFmt = parsed.numFmt;
+    if (!patch2.numFmt && parsed.numFmt && typeof value2 === "number") patch2.numFmt = parsed.numFmt;
   }
-  return { value: value2, text: text2, style: patchStyle(base, patch) };
+  return { value: value2, text: text2, style: patchStyle(base, patch2) };
 }
 
 // xlsx/edit/clipboard-text.ts
@@ -17866,10 +18476,10 @@ var SessionCalculator = class {
 
 // xlsx/edit/doc-properties.ts
 var same2 = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-function setDocumentProperties(ctx, patch) {
+function setDocumentProperties(ctx, patch2) {
   const prior = ctx.workbook.properties;
   const next = { ...prior };
-  for (const [key, value2] of Object.entries(patch)) {
+  for (const [key, value2] of Object.entries(patch2)) {
     if (value2 === void 0) continue;
     if (value2 === null) delete next[key];
     else next[key] = structuredClone(value2);
@@ -17922,6 +18532,444 @@ function deleteDrawing(ctx, s, index2) {
   );
 }
 
+// xlsx/edit/sparkline-xml.ts
+var XM4 = "http://schemas.microsoft.com/office/excel/2006/main";
+var URI = "{05C60535-1F16-4fd2-B633-F4F36F0B64E0}";
+var COLORS2 = [
+  "colorSeries",
+  "colorNegative",
+  "colorAxis",
+  "colorMarkers",
+  "colorFirst",
+  "colorLast",
+  "colorHigh",
+  "colorLow"
+];
+var SCALARS = [
+  "type",
+  "lineWeight",
+  "markers",
+  "high",
+  "low",
+  "first",
+  "last",
+  "negative",
+  "displayEmptyCellsAs",
+  "displayXAxis",
+  "displayHidden",
+  "rightToLeft",
+  "minAxisType",
+  "maxAxisType",
+  "manualMin",
+  "manualMax"
+];
+function cleanSparklinePatch(patch2) {
+  return Object.fromEntries(
+    [...SCALARS, ...COLORS2].flatMap((key) => patch2[key] === void 0 ? [] : [[key, patch2[key]]])
+  );
+}
+function patchSparklineNode(node, patch2) {
+  for (const key of SCALARS) {
+    const value2 = patch2[key];
+    if (value2 === void 0) continue;
+    node.setAttribute(key, typeof value2 === "boolean" ? value2 ? "1" : "0" : String(value2));
+  }
+  if (patch2.minAxisType && patch2.minAxisType !== "custom") node.removeAttribute("manualMin");
+  if (patch2.maxAxisType && patch2.maxAxisType !== "custom") node.removeAttribute("manualMax");
+  for (const key of COLORS2) {
+    const color = patch2[key];
+    if (!color) continue;
+    const fresh = parseXml(
+      `<x14:root xmlns:x14="${NS.x14}">${colorXml(color, `x14:${key}`)}</x14:root>`
+    ).documentElement.firstChild;
+    const replacement = node.ownerDocument.importNode(fresh, true);
+    const old = first(node, key, NS.x14);
+    if (old) node.replaceChild(replacement, old);
+    else {
+      const before = elements(node).find((child) => {
+        const index2 = COLORS2.indexOf(child.localName);
+        return index2 > COLORS2.indexOf(key) || child.localName === "f" || child.localName === "sparklines";
+      });
+      node.insertBefore(replacement, before ?? null);
+    }
+  }
+}
+function editSparklineXml(sheet, edit) {
+  return (sheet.preserved.get("extLst") ?? []).map((xml) => {
+    if (!xml.includes("sparklineGroup")) return xml;
+    const doc = parseXml(xml);
+    let changed = false;
+    for (const node of Array.from(doc.getElementsByTagNameNS(NS.x14, "sparklineGroup"))) {
+      if (!edit(node, readSparklineGroup(node))) continue;
+      changed = true;
+      const lines = first(node, "sparklines", NS.x14);
+      if (!lines || !children(lines, "sparkline", NS.x14).length) {
+        const groups = node.parentNode;
+        groups.removeChild(node);
+        if (!children(groups, "sparklineGroup", NS.x14).length)
+          groups.parentNode.removeChild(groups);
+      }
+    }
+    return changed ? buildXml(doc.documentElement) : xml;
+  });
+}
+function appendSparklineXml(sheet, groupXml) {
+  const source = [...sheet.preserved.get("extLst") ?? []];
+  const found = source.findIndex((xml) => xml.includes("sparklineGroups"));
+  const index2 = found >= 0 ? found : 0;
+  const doc = parseXml(source[index2] ?? `<extLst xmlns="${NS.x}"/>`);
+  const root = doc.documentElement;
+  let ext = children(root, "ext", NS.x).find(
+    (node) => node.getAttribute("uri")?.toUpperCase() === URI.toUpperCase()
+  );
+  if (!ext) {
+    ext = doc.createElementNS(NS.x, "ext");
+    ext.setAttribute("uri", URI);
+    ext.setAttribute("xmlns:x14", NS.x14);
+    root.appendChild(ext);
+  }
+  ext.setAttribute("uri", URI);
+  let groups = first(ext, "sparklineGroups", NS.x14);
+  if (!groups) {
+    groups = doc.createElementNS(NS.x14, "x14:sparklineGroups");
+    groups.setAttribute("xmlns:xm", XM4);
+    ext.appendChild(groups);
+  }
+  const fresh = doc.importNode(parseXml(groupXml).documentElement, true);
+  const revision = "http://schemas.microsoft.com/office/spreadsheetml/2015/revision2";
+  if (Array.from(doc.getElementsByTagNameNS(NS.x14, "sparklineGroup")).some(
+    (node) => node.hasAttributeNS(revision, "uid")
+  )) {
+    fresh.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xr2", revision);
+    fresh.setAttributeNS(revision, "xr2:uid", `{${globalThis.crypto.randomUUID().toUpperCase()}}`);
+  }
+  groups.appendChild(fresh);
+  source[index2] = buildXml(root);
+  return source;
+}
+
+// xlsx/edit/sparklines.ts
+function selectedSparklineGroups(sheet, ranges) {
+  return sheetSparklineGroups(sheet).filter(
+    (group) => group.sparklines.some((line2) => ranges.some((range2) => rangesIntersect(range2, line2.host)))
+  );
+}
+function validateSettings(group) {
+  for (const key of [
+    "markers",
+    "high",
+    "low",
+    "first",
+    "last",
+    "negative",
+    "displayXAxis",
+    "displayHidden",
+    "rightToLeft"
+  ])
+    if (typeof group[key] !== "boolean") throw new Error("The sparkline settings are not valid.");
+  if (!["line", "column", "stacked"].includes(group.type) || !["gap", "zero", "span"].includes(group.displayEmptyCellsAs) || !["individual", "group", "custom"].includes(group.minAxisType) || !["individual", "group", "custom"].includes(group.maxAxisType))
+    throw new Error("The sparkline settings are not valid.");
+  if (!Number.isFinite(group.lineWeight) || group.lineWeight < 0 || group.lineWeight > 1584)
+    throw new Error("The sparkline settings are not valid.");
+  if (group.minAxisType === "custom" && !Number.isFinite(group.manualMin) || group.maxAxisType === "custom" && !Number.isFinite(group.manualMax) || group.minAxisType === "custom" && group.maxAxisType === "custom" && group.manualMin > group.manualMax)
+    throw new Error("The sparkline axis limits are not valid.");
+  if (group.manualMin !== void 0 && group.minAxisType !== "custom" || group.manualMax !== void 0 && group.maxAxisType !== "custom")
+    throw new Error("The sparkline axis limits are not valid.");
+  for (const key of [
+    "colorSeries",
+    "colorNegative",
+    "colorAxis",
+    "colorMarkers",
+    "colorFirst",
+    "colorLast",
+    "colorHigh",
+    "colorLow"
+  ]) {
+    const color = group[key];
+    if (color !== void 0 && (color === null || typeof color !== "object" || Array.isArray(color) || ![color.rgb, color.theme, color.indexed].some((value2) => value2 !== void 0)))
+      throw new Error("The sparkline settings are not valid.");
+    if (color && (color.auto || color.rgb !== void 0 && !/^(?:[0-9a-f]{6}|[0-9a-f]{8})$/i.test(color.rgb) || color.theme !== void 0 && (!Number.isInteger(color.theme) || color.theme < 0 || color.theme > 11) || color.indexed !== void 0 && (!Number.isInteger(color.indexed) || color.indexed < 0 || color.indexed > 65) || color.tint !== void 0 && (!Number.isFinite(color.tint) || color.tint < -1 || color.tint > 1)))
+      throw new Error("The sparkline settings are not valid.");
+  }
+}
+function validatePatch(group, patch2) {
+  const next = { ...group, ...patch2 };
+  if (patch2.minAxisType && patch2.minAxisType !== "custom" && patch2.manualMin === void 0)
+    delete next.manualMin;
+  if (patch2.maxAxisType && patch2.maxAxisType !== "custom" && patch2.manualMax === void 0)
+    delete next.manualMax;
+  validateSettings(next);
+}
+function save(ctx, s, next, label3, ranges) {
+  const sheet = sheetAt(ctx.workbook, s);
+  ctx.run(
+    label3,
+    "annotations",
+    [{ kind: "parts", sheet: s, parts: ["preserved"] }],
+    () => sheet.preserved.set("extLst", next),
+    { sheet: s, ranges }
+  );
+}
+function createSparklineGroup(ctx, s, source, locations, patch2 = {}) {
+  patch2 = cleanSparklinePatch(patch2);
+  locations = checkedSparklineRange(locations);
+  const sheet = sheetAt(ctx.workbook, s);
+  const lines = newSparklines(ctx.workbook, s, source, locations);
+  if (selectedSparklineGroups(sheet, [locations]).length)
+    throw new Error("The location range already contains sparklines.");
+  if (sheet.merges.some((merge2) => lines.some((line2) => rangesIntersect(merge2, line2.host))))
+    throw new Error("Sparklines cannot be created in merged cells.");
+  const body2 = lines.map(
+    (line2) => `<x14:sparkline>${el("xm:f", {}, escapeText(line2.formula))}${el("xm:sqref", {}, formatRange(line2.host))}</x14:sparkline>`
+  ).join("");
+  const colors = '<x14:colorSeries theme="4"/><x14:colorNegative rgb="FFD00000"/><x14:colorAxis rgb="FF000000"/>' + ["Markers", "First", "Last", "High", "Low"].map((name) => `<x14:color${name} rgb="FFD00000"/>`).join("");
+  const doc = parseXml(
+    `<x14:sparklineGroup xmlns:x14="${NS.x14}" xmlns:xm="${XM4}">${colors}<x14:sparklines>${body2}</x14:sparklines></x14:sparklineGroup>`
+  );
+  const node = doc.documentElement;
+  validatePatch(readSparklineGroup(node), patch2);
+  patchSparklineNode(node, { displayEmptyCellsAs: "gap", ...patch2 });
+  validateSettings({ ...readSparklineGroup(node), ...patch2 });
+  save(ctx, s, appendSparklineXml(sheet, buildXml(node)), "Create sparklines", [locations]);
+}
+function setSparklineGroups(ctx, s, ranges, patch2) {
+  patch2 = cleanSparklinePatch(patch2);
+  const sheet = sheetAt(ctx.workbook, s);
+  ranges = ranges.map(checkedSparklineRange);
+  const selected2 = selectedSparklineGroups(sheet, ranges);
+  if (!selected2.length) return;
+  for (const group of selected2) validatePatch(group, patch2);
+  const next = editSparklineXml(sheet, (node, group) => {
+    if (!group.sparklines.some((line2) => ranges.some((range2) => rangesIntersect(range2, line2.host))))
+      return false;
+    patchSparklineNode(node, patch2);
+    return true;
+  });
+  save(ctx, s, next, "Format sparklines", ranges);
+}
+function setSparklineDateRange(ctx, s, ranges, source = "") {
+  ranges = ranges.map(checkedSparklineRange);
+  const sheet = sheetAt(ctx.workbook, s);
+  const groups = selectedSparklineGroups(sheet, ranges);
+  if (!groups.length) return;
+  let formula;
+  if (source.trim()) {
+    const data = sparklineDataRange(ctx.workbook, s, source);
+    const length = (range2) => {
+      const rows2 = range2.end.row - range2.start.row + 1;
+      const cols = range2.end.col - range2.start.col + 1;
+      if (rows2 > 1 && cols > 1) throw new Error("The date range must be one row or column.");
+      return Math.max(rows2, cols);
+    };
+    const count2 = length(data.range);
+    if (count2 > 1e4) throw new Error("The sparkline date range is too large.");
+    for (const group of groups)
+      for (const line2 of group.sparklines) {
+        const values2 = sparklineDataRange(ctx.workbook, s, line2.formula ?? "");
+        if (length(values2.range) !== count2)
+          throw new Error("The data range and date range do not match.");
+      }
+    formula = `'${ctx.workbook.sheets[data.sheet].name.replaceAll("'", "''")}'!${formatRange(data.range)}`;
+  }
+  const next = editSparklineXml(sheet, (node, group) => {
+    if (!group.sparklines.some((line2) => ranges.some((range2) => rangesIntersect(range2, line2.host))))
+      return false;
+    for (const old of children(node, "f", XM4)) node.removeChild(old);
+    node.setAttribute("dateAxis", formula ? "1" : "0");
+    if (formula) {
+      const value2 = node.ownerDocument.createElementNS(XM4, "xm:f");
+      value2.textContent = formula;
+      node.insertBefore(value2, first(node, "sparklines", NS.x14) ?? null);
+    }
+    return true;
+  });
+  save(ctx, s, next, "Change sparkline date axis", ranges);
+}
+function deleteSparklines(ctx, s, ranges, wholeGroups = false) {
+  ranges = ranges.map(checkedSparklineRange);
+  const sheet = sheetAt(ctx.workbook, s);
+  if (!selectedSparklineGroups(sheet, ranges).length) return;
+  const next = editSparklineXml(sheet, (node, group) => {
+    if (!group.sparklines.some((line2) => ranges.some((range2) => rangesIntersect(range2, line2.host))))
+      return false;
+    const lines = first(node, "sparklines", NS.x14);
+    const nodes = children(lines, "sparkline", NS.x14);
+    for (const line2 of nodes) {
+      const host = parseRange(first(line2, "sqref", XM4)?.textContent ?? "");
+      if (wholeGroups || host && ranges.some((range2) => rangesIntersect(range2, host)))
+        line2.parentNode?.removeChild(line2);
+    }
+    return true;
+  });
+  save(ctx, s, next, "Clear sparklines", ranges);
+}
+
+// xlsx/edit/pivots.ts
+function pivotAt(ctx, sheet, name) {
+  const pivot = sheetAt(ctx.workbook, sheet).pivotTables?.find((entry) => entry.name === name);
+  if (!pivot) throw new Error("The selected PivotTable is not available.");
+  return pivot;
+}
+function uniqueName(ctx) {
+  const used = reservedPivotNames(ctx.workbook);
+  for (let i2 = 1; ; i2++) if (!used.has(`pivottable${i2}`)) return `PivotTable${i2}`;
+}
+function reservedPivotNames(workbook) {
+  return new Set(
+    workbook.sheets.flatMap((sheet) => [
+      ...(sheet.pivotTables ?? []).map((pivot) => pivot.name),
+      ...sheet.preserved.get("source:unsupportedPivotNames") ?? []
+    ]).map((name) => name.toLowerCase())
+  );
+}
+function checkName(ctx, name) {
+  if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) || name.length > 255 || parseAddress(name) || reservedPivotNames(ctx.workbook).has(name.toLowerCase()))
+    throw new Error("A PivotTable name must be unique and cannot look like a cell reference.");
+}
+function plan(ctx, s, pivot, old) {
+  const sheet = sheetAt(ctx.workbook, s);
+  const grid6 = pivotGrid(pivot);
+  const start = pivot.location.start;
+  const location = {
+    start,
+    end: {
+      row: start.row + grid6.values.length - 1,
+      col: start.col + (grid6.values[0]?.length ?? 0) - 1
+    }
+  };
+  if (![start.row, start.col].every(Number.isInteger) || start.row < 0 || start.col < 0 || location.end.row > MAX_ROW || location.end.col > MAX_COL)
+    throw new Error("The PivotTable result does not fit on the worksheet.");
+  const source = sparklineDataRange(ctx.workbook, s, pivot.source);
+  if (source.sheet === s && rangesIntersect(source.range, location) || sheet.merges.some((range2) => rangesIntersect(range2, location)) || sheet.tables.some((table2) => rangesIntersect(table2.range, location)) || sheet.pivotTables?.some((other) => other !== old && rangesIntersect(other.location, location)))
+    throw new Error("The PivotTable would overlap source data, another table or merged cells.");
+  let occupied = false;
+  forEachCellInRange(sheet, location, (cell, row2, col) => {
+    if ((!old || !rangeContains(old.location, { row: row2, col })) && (cell.value !== null || cell.formula !== void 0))
+      occupied = true;
+  });
+  if (occupied) throw new Error("The PivotTable would overwrite existing cell content.");
+  return { grid: grid6, location };
+}
+function write(ctx, s, pivot, old) {
+  const sheet = sheetAt(ctx.workbook, s);
+  const { grid: grid6, location } = plan(ctx, s, pivot, old);
+  const ranges = [...old ? [old.location] : [], location];
+  ctx.run(
+    old ? "Refresh PivotTable" : "Create PivotTable",
+    "annotations",
+    [
+      { kind: "parts", sheet: s, parts: ["pivotTables"] },
+      { kind: "cells", sheet: s, ranges }
+    ],
+    () => {
+      const compact3 = pivot.layout === "compact";
+      const indents = [
+        stylePatcher(ctx.workbook, {
+          alignment: { indent: 0, ...compact3 ? { horizontal: "left" } : {} }
+        }),
+        stylePatcher(ctx.workbook, { alignment: { indent: 1, horizontal: "left" } })
+      ];
+      const styles = /* @__PURE__ */ new Map();
+      forEachCellInRange(sheet, location, (cell, row2, col) => {
+        if (cell.styleId !== void 0) styles.set(`${row2}:${col}`, cell.styleId);
+      });
+      if (old)
+        forEachCellInRange(sheet, old.location, (cell, row2, col) => {
+          if (cell.styleId !== void 0)
+            putCell(sheet, row2, col, { value: null, styleId: cell.styleId });
+          else deleteCell(sheet, row2, col);
+        });
+      const next = { ...pivot, location, dirty: true };
+      const list = sheet.pivotTables ?? [];
+      sheet.pivotTables = old ? list.map((entry) => entry === old ? next : entry) : [...list, next];
+      grid6.values.forEach(
+        (line2, row2) => line2.forEach((value2, col) => {
+          const r = startRow(location, row2);
+          const c = location.start.col + col;
+          let styleId = styles.get(`${r}:${c}`);
+          if (col < (grid6.rowLabelColumns ?? 1)) {
+            const indent = col === 0 ? grid6.indents?.[row2] ?? 0 : 0;
+            const alignment = styleAt(ctx.workbook, styleId).alignment;
+            if ((alignment?.indent ?? 0) !== indent || compact3 && alignment?.horizontal !== "left")
+              styleId = indents[indent](styleId);
+          }
+          putCell(sheet, r, c, { value: value2, ...styleId !== void 0 ? { styleId } : {} });
+        })
+      );
+    },
+    { sheet: s, ranges }
+  );
+}
+var startRow = (range2, offset2) => range2.start.row + offset2;
+function createPivotTable(ctx, s, destination, options) {
+  const data = pivotSourceData(ctx.workbook, s, options.source);
+  const name = options.name ?? uniqueName(ctx);
+  checkName(ctx, name);
+  const aggregate3 = options.aggregate ?? "sum";
+  const pivot = {
+    ...data,
+    name,
+    rowField: options.rowField,
+    layout: options.layout ?? "tabular",
+    subtotalPosition: options.subtotalPosition ?? (options.layout && options.layout !== "tabular" ? "top" : "bottom"),
+    ...options.secondRowField ? { secondRowField: options.secondRowField } : {},
+    ...options.subtotals !== void 0 ? { subtotals: options.subtotals } : {},
+    ...options.repeatLabels !== void 0 ? { repeatLabels: options.repeatLabels } : {},
+    valueField: options.valueField,
+    aggregate: aggregate3,
+    valueCaption: pivotCaption(aggregate3, options.valueField),
+    location: { start: { ...destination }, end: { ...destination } },
+    ...options.columnField ? { columnField: options.columnField } : {}
+  };
+  validatePivotFields(pivot);
+  write(ctx, s, pivot);
+  return name;
+}
+function refreshPivotTable(ctx, s, name, patch2 = {}) {
+  const old = pivotAt(ctx, s, name);
+  const aggregate3 = patch2.aggregate ?? old.aggregate;
+  const valueField = patch2.valueField ?? old.valueField;
+  const next = {
+    ...old,
+    ...pivotSourceData(ctx.workbook, s, old.source),
+    rowField: patch2.rowField ?? old.rowField,
+    valueField,
+    aggregate: aggregate3,
+    valueCaption: aggregate3 === old.aggregate && valueField === old.valueField ? old.valueCaption : pivotCaption(aggregate3, valueField)
+  };
+  if (patch2.columnField !== void 0) {
+    if (patch2.columnField) next.columnField = patch2.columnField;
+    else delete next.columnField;
+  }
+  if (patch2.secondRowField !== void 0) {
+    if (patch2.secondRowField) next.secondRowField = patch2.secondRowField;
+    else delete next.secondRowField;
+  }
+  if (patch2.subtotals !== void 0) next.subtotals = patch2.subtotals;
+  if (patch2.repeatLabels !== void 0) next.repeatLabels = patch2.repeatLabels;
+  if (patch2.layout !== void 0) next.layout = patch2.layout;
+  if (patch2.subtotalPosition !== void 0) next.subtotalPosition = patch2.subtotalPosition;
+  validatePivotFields(next);
+  write(ctx, s, next, old);
+}
+function deletePivotTable(ctx, s, name) {
+  const sheet = sheetAt(ctx.workbook, s);
+  const pivot = pivotAt(ctx, s, name);
+  ctx.run(
+    "Delete PivotTable",
+    "annotations",
+    [
+      { kind: "parts", sheet: s, parts: ["pivotTables"] },
+      { kind: "cells", sheet: s, ranges: [pivot.location] }
+    ],
+    () => {
+      sheet.pivotTables = sheet.pivotTables.filter((entry) => entry !== pivot);
+      forEachCellInRange(sheet, pivot.location, (_cell, row2, col) => deleteCell(sheet, row2, col));
+    },
+    { sheet: s, ranges: [pivot.location] }
+  );
+}
+
 // xlsx/edit/cell-style.ts
 function ensureNamedStyle(workbook, name) {
   const lower2 = name.toLowerCase();
@@ -18029,19 +19077,19 @@ function addChart(ctx, s, chart) {
     { sheet: s }
   );
 }
-function updateChart(ctx, s, index2, patch) {
-  assertBarClusterOptions(patch);
+function updateChart(ctx, s, index2, patch2) {
+  assertBarClusterOptions(patch2);
   const sheet = sheetAt(ctx.workbook, s);
   const chart = sheet.drawings[index2];
   if (!chart || chart.kind !== "chart") throw new RangeError(`No chart at index ${index2}`);
-  const formatting = patch.elementFills ? chartWithElementFills(chart, patch.elementFills).formatting : void 0;
+  const formatting = patch2.elementFills ? chartWithElementFills(chart, patch2.elementFills).formatting : void 0;
   ctx.run(
     "Edit chart",
     "annotations",
     [{ kind: "sheet", sheet: s }],
     () => {
       const live = sheet.drawings[index2];
-      const changes = structuredClone(patch);
+      const changes = structuredClone(patch2);
       delete changes.elementFills;
       if (formatting) live.formatting = formatting;
       changes.series?.forEach((series, i2) => {
@@ -18267,6 +19315,8 @@ function resizeTableIn(workbook, sheet, id, range2) {
     throw new Error("The table range is too small.");
   if (sheet.tables.some((t) => t !== table2 && rangesIntersect(t.range, r)))
     throw new Error("A table cannot overlap another table.");
+  if (sheet.pivotTables?.some((pivot) => rangesIntersect(pivot.location, r)))
+    throw new Error("A table cannot overlap a PivotTable.");
   if (sheet.merges.some((m) => rangesIntersect(m, r)))
     throw new Error("A table cannot contain merged cells.");
   const oldEnd = table2.range.end.row;
@@ -18289,17 +19339,17 @@ var STYLE_KEYS = [
   "showFirstColumn",
   "showLastColumn"
 ];
-function updateTable(ctx, s, ref, patch) {
+function updateTable(ctx, s, ref, patch2) {
   const { workbook } = ctx;
   const sheet = sheetAt(workbook, s);
   const current = sheet.tables[tableIndex(sheet, ref)];
-  const name = patch.name ?? patch.displayName;
+  const name = patch2.name ?? patch2.displayName;
   const renaming = name !== void 0 && name !== current.name;
   if (renaming) {
     const problem = validateTableName(workbook, name, current);
     if (problem) throw new Error(problem);
   }
-  const wide = renaming || patch.headerRow !== void 0 || patch.totalsRow !== void 0;
+  const wide = renaming || patch2.headerRow !== void 0 || patch2.totalsRow !== void 0;
   const scope = wide ? { kind: "workbook" } : { kind: "sheet", sheet: s };
   const id = current.id;
   ctx.run(
@@ -18310,25 +19360,25 @@ function updateTable(ctx, s, ref, patch) {
       const table2 = byId(sheet, id);
       if (renaming) renameTableIn(workbook, table2, name);
       for (const key of STYLE_KEYS) {
-        if (!(key in patch)) continue;
-        const value2 = patch[key];
+        if (!(key in patch2)) continue;
+        const value2 = patch2[key];
         if (value2 === void 0) delete table2[key];
         else table2[key] = value2;
       }
-      if (patch.columns) {
+      if (patch2.columns) {
         const width = table2.range.end.col - table2.range.start.col + 1;
-        if (patch.columns.length !== width) throw new Error("Give one column per table column.");
+        if (patch2.columns.length !== width) throw new Error("Give one column per table column.");
         const before = table2.columns;
-        table2.columns = structuredClone(patch.columns);
+        table2.columns = structuredClone(patch2.columns);
         for (const [index2, column] of table2.columns.entries()) {
           const sourceId = before[index2]?.sourceId;
           if (column.sourceId === void 0 && sourceId !== void 0) column.sourceId = sourceId;
         }
       }
-      if (patch.headerRow !== void 0) setHeaderRow(workbook, sheet, id, patch.headerRow);
-      if (patch.totalsRow !== void 0) setTotalsRow(workbook, sheet, id, patch.totalsRow);
-      else if (patch.columns && table2.totalsRow) applyTotalsRow(sheet, byId(sheet, id));
-      if (patch.range) resizeTableIn(workbook, sheet, id, patch.range);
+      if (patch2.headerRow !== void 0) setHeaderRow(workbook, sheet, id, patch2.headerRow);
+      if (patch2.totalsRow !== void 0) setTotalsRow(workbook, sheet, id, patch2.totalsRow);
+      else if (patch2.columns && table2.totalsRow) applyTotalsRow(sheet, byId(sheet, id));
+      if (patch2.range) resizeTableIn(workbook, sheet, id, patch2.range);
     },
     { sheet: s, ranges: [current.range], structural: true }
   );
@@ -18510,36 +19560,233 @@ function compact2(value2) {
     if (value2[key] === void 0) delete value2[key];
   return value2;
 }
-function setPageSetup(ctx, s, patch) {
+function setPageSetup(ctx, s, patch2) {
   const sheet = sheetAt(ctx.workbook, s);
   ctx.run(
     "Page setup",
     "view",
     [{ kind: "sheet", sheet: s }],
     () => {
-      const next = compact2({ ...sheet.pageSetup, ...structuredClone(patch) });
+      const next = compact2({ ...sheet.pageSetup, ...structuredClone(patch2) });
       if (Object.keys(next).length) sheet.pageSetup = next;
       else Reflect.deleteProperty(sheet, "pageSetup");
     },
     { sheet: s }
   );
 }
-function setPrintOptions(ctx, s, patch) {
-  const sheet = sheetAt(ctx.workbook, s);
-  ctx.run(
-    "Print options",
-    "view",
-    [{ kind: "sheet", sheet: s }],
-    () => {
-      const next = { ...sheet.printOptions, ...patch };
-      for (const key of Object.keys(next))
-        if (!next[key]) delete next[key];
-      if (Object.keys(next).length) sheet.printOptions = next;
-      else Reflect.deleteProperty(sheet, "printOptions");
-      sheet.preserved.delete("printOptions");
-    },
-    { sheet: s }
-  );
+function setPrintOptions(ctx, s, patch2) {
+  const sheet = sheetAt(ctx.workbook, s);
+  ctx.run(
+    "Print options",
+    "view",
+    [{ kind: "sheet", sheet: s }],
+    () => {
+      const next = { ...sheet.printOptions, ...patch2 };
+      for (const key of Object.keys(next))
+        if (!next[key]) delete next[key];
+      if (Object.keys(next).length) sheet.printOptions = next;
+      else Reflect.deleteProperty(sheet, "printOptions");
+      sheet.preserved.delete("printOptions");
+    },
+    { sheet: s }
+  );
+}
+
+// xlsx/edit/page-breaks.ts
+function patch(xml, before, present, axis) {
+  const doc = parseXml(xml);
+  const root = doc.documentElement;
+  const breaks = children(root, "brk", NS.x);
+  for (const node of breaks)
+    if (!present && /^(1|true)$/.test(node.getAttribute("man") ?? "") && (before === void 0 || Number(node.getAttribute("id")) === before))
+      root.removeChild(node);
+  if (present && before !== void 0) {
+    const existing = children(root, "brk", NS.x).find(
+      (node2) => Number(node2.getAttribute("id")) === before
+    );
+    const node = existing ?? doc.createElementNS(NS.x, "brk");
+    node.setAttribute("id", String(before));
+    node.setAttribute("min", "0");
+    node.setAttribute("max", String(axis === "row" ? MAX_COL : MAX_ROW));
+    node.setAttribute("man", "1");
+    if (!existing) root.appendChild(node);
+  }
+  const remaining = children(root, "brk", NS.x);
+  if (remaining.filter((node) => /^(1|true)$/.test(node.getAttribute("man") ?? "")).length > 1026)
+    throw new Error("A worksheet can have at most 1026 manual breaks on each axis.");
+  if (!elements(root).length) return void 0;
+  root.setAttribute("count", String(remaining.length));
+  root.setAttribute(
+    "manualBreakCount",
+    String(remaining.filter((node) => /^(1|true)$/.test(node.getAttribute("man") ?? "")).length)
+  );
+  return buildXml(root);
+}
+function setPageBreak(ctx, s, axis, before, present = true) {
+  if (typeof present !== "boolean" || !["row", "col"].includes(axis) || !Number.isInteger(before) || before <= 0 || before > (axis === "row" ? MAX_ROW : MAX_COL))
+    throw new RangeError("Choose a row or column after the first to set a page break.");
+  const sheet = sheetAt(ctx.workbook, s);
+  const key = axis === "row" ? "rowBreaks" : "colBreaks";
+  const source = sheet.preserved.get(key) ?? [`<${key} xmlns="${NS.x}"/>`];
+  const result2 = source.flatMap((xml, index2) => {
+    const next = patch(xml, before, present && index2 === 0, axis);
+    return next ? [next] : [];
+  });
+  ctx.run(
+    present ? "Insert page break" : "Remove page break",
+    "view",
+    [{ kind: "parts", sheet: s, parts: ["preserved"] }],
+    () => {
+      if (result2.length) sheet.preserved.set(key, result2);
+      else sheet.preserved.delete(key);
+    },
+    { sheet: s }
+  );
+}
+function resetPageBreaks(ctx, s) {
+  const sheet = sheetAt(ctx.workbook, s);
+  const next = ["row", "col"].map((axis) => {
+    const key = axis === "row" ? "rowBreaks" : "colBreaks";
+    return {
+      key,
+      xml: (sheet.preserved.get(key) ?? []).flatMap((xml) => {
+        const result2 = patch(xml, void 0, false, axis);
+        return result2 ? [result2] : [];
+      })
+    };
+  });
+  ctx.run(
+    "Reset page breaks",
+    "view",
+    [{ kind: "parts", sheet: s, parts: ["preserved"] }],
+    () => {
+      for (const entry of next) {
+        if (entry.xml.length) sheet.preserved.set(entry.key, entry.xml);
+        else sheet.preserved.delete(entry.key);
+      }
+    },
+    { sheet: s }
+  );
+}
+
+// xlsx/layout/print-titles.ts
+var PRINT_TITLES_NAME = "_xlnm.Print_Titles";
+function refs(ast) {
+  return ast.type === "binary" && ast.op === "," ? [...refs(ast.left), ...refs(ast.right)] : [ast];
+}
+function printTitles(workbook, sheetIndex2) {
+  const name = workbook.definedNames.find(
+    (entry) => entry.name === PRINT_TITLES_NAME && entry.localSheet === sheetIndex2
+  );
+  if (!name) return {};
+  try {
+    const result2 = {};
+    for (const node of refs(parseFormula(`(${name.formula})`))) {
+      if (node.type !== "ref" || !node.ref || node.prefix?.book || node.prefix?.sheet2 || node.spill || node.prefix && node.prefix.sheet.toLowerCase() !== workbook.sheets[sheetIndex2]?.name.toLowerCase())
+        throw new Error("Unsupported print title reference");
+      const key = node.ref.kind === "rows" ? "rows" : node.ref.kind === "cols" ? "columns" : void 0;
+      if (!key || result2[key]) throw new Error("Unsupported print title reference");
+      const axis = key === "rows" ? "row" : "col";
+      result2[key] = {
+        start: Math.min(node.ref.start[axis], node.ref.end[axis]),
+        end: Math.max(node.ref.start[axis], node.ref.end[axis])
+      };
+    }
+    return result2;
+  } catch {
+    return { unsupported: true };
+  }
+}
+function formatPrintTitleSpan(span4, axis) {
+  return axis === "row" ? `$${span4.start + 1}:$${span4.end + 1}` : `$${columnLabel(span4.start)}:$${columnLabel(span4.end)}`;
+}
+function printTitlesFormula(sheet, titles) {
+  return ["rows", "columns"].flatMap((key) => {
+    const span4 = titles[key];
+    if (!span4) return [];
+    const max = key === "rows" ? MAX_ROW : MAX_COL;
+    if (![span4.start, span4.end].every(Number.isInteger) || span4.start < 0 || span4.end < span4.start || span4.end > max)
+      throw new Error("Print titles must be whole rows or whole columns.");
+    return [
+      `${quoteSheetName(sheet)}!${formatPrintTitleSpan(span4, key === "rows" ? "row" : "col")}`
+    ];
+  }).join(",");
+}
+
+// xlsx/edit/view.ts
+function setFreeze(ctx, s, freeze) {
+  const sheet = sheetAt(ctx.workbook, s);
+  const next = freeze && (freeze.rows > 0 || freeze.cols > 0) ? { rows: Math.max(0, freeze.rows), cols: Math.max(0, freeze.cols) } : void 0;
+  ctx.run(
+    next ? "Freeze panes" : "Unfreeze panes",
+    "view",
+    [{ kind: "sheet", sheet: s }],
+    () => {
+      if (next) sheet.view.freeze = next;
+      else delete sheet.view.freeze;
+    },
+    { sheet: s, structural: true }
+  );
+}
+function setSheetView(ctx, s, patch2) {
+  const sheet = sheetAt(ctx.workbook, s);
+  ctx.run(
+    "Sheet view",
+    "view",
+    [{ kind: "sheet", sheet: s }],
+    () => {
+      const view = { ...sheet.view, ...structuredClone(patch2) };
+      for (const key of Object.keys(view))
+        if (view[key] === void 0) delete view[key];
+      if (patch2.zoom !== void 0) view.zoom = Math.max(10, Math.min(400, Math.round(patch2.zoom)));
+      sheet.view = view;
+    },
+    { sheet: s, structural: patch2.zoom !== void 0 || "freeze" in patch2 }
+  );
+}
+var NAME_PATTERN = /^[A-Za-z_\\][A-Za-z0-9_.\\?]*$/;
+function validateDefinedName(name) {
+  if (!name || name.length > 255) return "A name must have 1 to 255 characters.";
+  if (!NAME_PATTERN.test(name))
+    return "A name must start with a letter, underscore or backslash and contain no spaces.";
+  if (parseAddress(name) || /^[RrCc]$/.test(name) || /^R\d*C\d*$/i.test(name))
+    return "A name cannot look like a cell reference.";
+  return void 0;
+}
+var sameName = (a, name, localSheet) => a.name.toLowerCase() === name.toLowerCase() && a.localSheet === localSheet;
+function setDefinedName(ctx, name) {
+  const problem = name.name.startsWith("_xlnm.") ? void 0 : validateDefinedName(name.name);
+  if (problem) throw new Error(problem);
+  if (name.localSheet !== void 0) sheetAt(ctx.workbook, name.localSheet);
+  const entry = structuredClone(name);
+  entry.formula = entry.formula.replace(/^=/, "");
+  ctx.run("Define name", "names", [{ kind: "meta" }], () => {
+    const { definedNames } = ctx.workbook;
+    const index2 = definedNames.findIndex((n) => sameName(n, name.name, name.localSheet));
+    if (index2 >= 0) definedNames[index2] = entry;
+    else definedNames.push(entry);
+  });
+}
+function deleteDefinedName(ctx, name, localSheet) {
+  const index2 = ctx.workbook.definedNames.findIndex((n) => sameName(n, name, localSheet));
+  if (index2 < 0) return;
+  ctx.run("Delete name", "names", [{ kind: "meta" }], () => {
+    ctx.workbook.definedNames.splice(index2, 1);
+  });
+}
+
+// xlsx/edit/print-titles.ts
+function setPrintTitles(ctx, sheet, patch2) {
+  const ws = sheetAt(ctx.workbook, sheet);
+  const existing = printTitles(ctx.workbook, sheet);
+  if (existing.unsupported && !Object.hasOwn(patch2, "rows") && !Object.hasOwn(patch2, "columns"))
+    return;
+  if (existing.unsupported && (!Object.hasOwn(patch2, "rows") || !Object.hasOwn(patch2, "columns")))
+    throw new Error("Replace both print title ranges to change unsupported titles.");
+  const next = { ...existing, ...patch2 };
+  const formula = printTitlesFormula(ws.name, next);
+  if (formula) setDefinedName(ctx, { name: PRINT_TITLES_NAME, formula, localSheet: sheet });
+  else deleteDefinedName(ctx, PRINT_TITLES_NAME, sheet);
 }
 
 // digest/algorithm-names.ts
@@ -19826,12 +21073,12 @@ function compress3(h2, data, offset2) {
     W3[i2 * 2 + 1] = lo;
   }
   let ah = h2[0], al = h2[1], bh = h2[2], bl = h2[3], ch = h2[4], cl = h2[5], dh = h2[6], dl = h2[7];
-  let eh = h2[8], el = h2[9], fh = h2[10], fl = h2[11], gh = h2[12], gl = h2[13], hh = h2[14], hl = h2[15];
+  let eh = h2[8], el2 = h2[9], fh = h2[10], fl = h2[11], gh = h2[12], gl = h2[13], hh = h2[14], hl = h2[15];
   for (let i2 = 0; i2 < 80; i2++) {
-    const S1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
-    const S1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
+    const S1h = (eh >>> 14 | el2 << 18) ^ (eh >>> 18 | el2 << 14) ^ (el2 >>> 9 | eh << 23);
+    const S1l = (el2 >>> 14 | eh << 18) ^ (el2 >>> 18 | eh << 14) ^ (eh >>> 9 | el2 << 23);
     const chh = eh & fh ^ ~eh & gh;
-    const chl = el & fl ^ ~el & gl;
+    const chl = el2 & fl ^ ~el2 & gl;
     let t1l = (hl >>> 0) + (S1l >>> 0) + (chl >>> 0) + K4[i2 * 2 + 1] + W3[i2 * 2 + 1];
     const t1h = hh + S1h + chh + K4[i2 * 2] + W3[i2 * 2] + Math.floor(t1l / 4294967296);
     t1l >>>= 0;
@@ -19847,10 +21094,10 @@ function compress3(h2, data, offset2) {
     gh = fh;
     gl = fl;
     fh = eh;
-    fl = el;
+    fl = el2;
     let nl = (dl >>> 0) + t1l;
     eh = dh + t1h + Math.floor(nl / 4294967296) >>> 0;
-    el = nl >>> 0;
+    el2 = nl >>> 0;
     dh = ch;
     dl = cl;
     ch = bh;
@@ -19870,7 +21117,7 @@ function compress3(h2, data, offset2) {
   add2(2, bh, bl);
   add2(4, ch, cl);
   add2(6, dh, dl);
-  add2(8, eh, el);
+  add2(8, eh, el2);
   add2(10, fh, fl);
   add2(12, gh, gl);
   add2(14, hh, hl);
@@ -20421,6 +21668,8 @@ function merge(ctx, s, range2, mode) {
   if (r.start.row === r.end.row && r.start.col === r.end.col) return;
   if (sheet.tables.some((t) => rangesIntersect(t.range, r)))
     throw new Error("Cells inside a table cannot be merged.");
+  if (sheet.pivotTables?.some((pivot) => rangesIntersect(pivot.location, r)))
+    throw new Error("Cells inside a PivotTable cannot be merged.");
   const targets = mergeTargets(r, mode);
   if (!targets.length) return;
   ctx.run(
@@ -20471,322 +21720,106 @@ function unmerge(ctx, s, range2) {
     "Unmerge cells",
     "format",
     [{ kind: "parts", sheet: s, parts: ["merges"] }],
-    () => {
-      sheet.merges = sheet.merges.filter((m) => !rangesIntersect(m, r));
-    },
-    { sheet: s, ranges: [r] }
-  );
-}
-
-// xlsx/layout/style-view.ts
-var BLACK = "#000000";
-var WHITE = "#FFFFFF";
-var PX_PER_PT = 96 / 72;
-function mergeFont(base, font) {
-  if (!font) return base;
-  const out = { ...base };
-  for (const [key, value2] of Object.entries(font))
-    if (value2 !== void 0) out[key] = value2;
-  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 = {
-    family,
-    sizePx: (font.size && font.size > 0 ? font.size : 11) * PX_PER_PT,
-    bold: font.bold === true,
-    italic: font.italic === true,
-    strike: font.strike === true,
-    color: resolveColor(font.color, theme2, BLACK) ?? BLACK
-  };
-  if (font.underline)
-    view.underline = font.underline === "double" || font.underline === "doubleAccounting" ? "double" : "single";
-  if (font.vertAlign === "superscript") view.vertAlign = "super";
-  else if (font.vertAlign === "subscript") view.vertAlign = "sub";
-  return view;
-}
-function fillView(fill, theme2, differential = false) {
-  if (!fill) return void 0;
-  if (fill.type === "gradient") {
-    const stops = [...fill.stops].sort((a, b) => a.position - b.position).map((stop) => `${resolveColor(stop.color, theme2, WHITE)} ${round2(stop.position * 100)}%`);
-    if (stops.length === 0) return void 0;
-    if (stops.length === 1) stops.push(stops[0] ?? WHITE);
-    const css = fill.gradient === "path" ? `radial-gradient(circle, ${stops.join(", ")})` : `linear-gradient(${round2(((fill.degree ?? 0) + 90) % 360)}deg, ${stops.join(", ")})`;
-    return { gradient: css };
-  }
-  if (fill.pattern === "none") {
-    if (differential && fill.bgColor)
-      return { background: resolveColor(fill.bgColor, theme2, WHITE) ?? WHITE };
-    return void 0;
-  }
-  if (fill.pattern === "solid") {
-    const color = differential ? fill.bgColor ?? fill.fgColor : fill.fgColor ?? fill.bgColor;
-    return { background: resolveColor(color, theme2, BLACK) ?? BLACK };
-  }
-  return {
-    pattern: fill.pattern,
-    fg: resolveColor(fill.fgColor, theme2, BLACK) ?? BLACK,
-    bg: resolveColor(fill.bgColor, theme2, WHITE) ?? WHITE
-  };
-}
-var round2 = (n) => Math.round(n * 100) / 100;
-var BORDER_STYLES = {
-  hair: { widthPx: 1, style: "dotted" },
-  thin: { widthPx: 1, style: "solid" },
-  dotted: { widthPx: 1, style: "dotted" },
-  dashed: { widthPx: 1, style: "dashed" },
-  dashDot: { widthPx: 1, style: "dashed" },
-  dashDotDot: { widthPx: 1, style: "dashed" },
-  medium: { widthPx: 2, style: "solid" },
-  mediumDashed: { widthPx: 2, style: "dashed" },
-  mediumDashDot: { widthPx: 2, style: "dashed" },
-  mediumDashDotDot: { widthPx: 2, style: "dashed" },
-  slantDashDot: { widthPx: 2, style: "dashed" },
-  thick: { widthPx: 3, style: "solid" },
-  double: { widthPx: 3, style: "double" }
-};
-function edgeView(edge, theme2) {
-  if (!edge) return void 0;
-  const style2 = BORDER_STYLES[edge.style];
-  if (!style2) return void 0;
-  return { ...style2, color: resolveColor(edge.color, theme2, BLACK) ?? BLACK };
-}
-function mergeBorder(base, border) {
-  if (!border) return base;
-  const out = { ...base };
-  for (const [key, value2] of Object.entries(border))
-    if (value2 !== void 0) out[key] = value2;
-  return out;
-}
-function bordersView(border, theme2) {
-  const out = {};
-  const set = (key, edge) => {
-    const view = edgeView(edge, theme2);
-    if (view) out[key] = view;
-  };
-  set("top", border.top);
-  set("right", border.right);
-  set("bottom", border.bottom);
-  set("left", border.left);
-  if (border.diagonalUp) set("diagonalUp", border.diagonal);
-  if (border.diagonalDown) set("diagonalDown", border.diagonal);
-  return out;
-}
-
-// xlsx/layout/sparkline-view.ts
-var DEFAULTS = {
-  colorSeries: "#376092",
-  colorNegative: "#D00000",
-  colorAxis: "#000000",
-  colorMarkers: "#D00000",
-  colorFirst: "#D00000",
-  colorLast: "#D00000",
-  colorHigh: "#D00000",
-  colorLow: "#D00000"
-};
-var COLUMN_GAP = 0.2;
-function extent(values2) {
-  let min = Infinity;
-  let max = -Infinity;
-  for (const v of values2) {
-    if (v === null) continue;
-    if (v < min) min = v;
-    if (v > max) max = v;
-  }
-  return min <= max ? { min, max } : void 0;
-}
-function sparklineValues(group, values2) {
-  return group.displayEmptyCellsAs === "zero" ? values2.map((v) => v ?? 0) : [...values2];
-}
-function sparklineScale(group, all2, index2) {
-  const own = extent(sparklineValues(group, all2[index2]?.values ?? []));
-  const needsGroup = group.minAxisType === "group" || group.maxAxisType === "group";
-  const shared = needsGroup ? extent(all2.flatMap((data) => sparklineValues(group, data.values))) : void 0;
-  const end = (type, manual, key) => {
-    if (type === "custom" && manual !== void 0) return manual;
-    if (type === "group" && shared) return shared[key];
-    return own?.[key];
-  };
-  const min = end(group.minAxisType, group.manualMin, "min");
-  const max = end(group.maxAxisType, group.manualMax, "max");
-  return min === void 0 || max === void 0 ? void 0 : { min, max };
-}
-function positions(group, data, n) {
-  const dates = data.dates;
-  if (group.dateAxis && dates && dates.length === n) {
-    const span4 = extent(dates);
-    if (span4) {
-      const width = span4.max - span4.min;
-      return dates.map((d) => d === null ? null : width ? (d - span4.min) / width : 0.5);
-    }
-  }
-  return Array.from({ length: n }, (_, i2) => n === 1 ? 0.5 : i2 / (n - 1));
-}
-function pointFacts(values2) {
-  const numbers3 = values2.filter((x) => x !== null);
-  let last = values2.length - 1;
-  while (last >= 0 && values2[last] === null) last--;
-  return {
-    high: Math.max(...numbers3),
-    low: Math.min(...numbers3),
-    first: values2.findIndex((x) => x !== null),
-    last
-  };
-}
-function pointColor(group, v, i2, facts, colors, markers) {
-  let color = markers && group.markers ? colors.colorMarkers : void 0;
-  if (group.negative && v < 0) color = colors.colorNegative;
-  if (group.high && v === facts.high) color = colors.colorHigh;
-  if (group.low && v === facts.low) color = colors.colorLow;
-  if (group.first && i2 === facts.first) color = colors.colorFirst;
-  if (group.last && i2 === facts.last) color = colors.colorLast;
-  return color;
-}
-function resolveColors(group, theme2) {
-  const out = { ...DEFAULTS };
-  for (const key of Object.keys(DEFAULTS)) {
-    const color = group[key];
-    out[key] = resolveColor(color, theme2, DEFAULTS[key]) ?? DEFAULTS[key];
-  }
-  return out;
-}
-function sparklineView(group, data, scale2, theme2) {
-  const colors = resolveColors(group, theme2);
-  const view = {
-    type: group.type,
-    color: colors.colorSeries,
-    lineWeightPt: group.lineWeight,
-    lines: [],
-    markers: [],
-    columns: []
-  };
-  const values2 = sparklineValues(group, data.values);
-  const n = values2.length;
-  if (!n || !scale2) return view;
-  const facts = pointFacts(values2);
-  const xs = positions(group, data, n);
-  const flip = (x) => group.rightToLeft ? 1 - x : x;
-  const range2 = scale2.max - scale2.min;
-  const yOf = (v) => range2 ? Math.max(0, Math.min(1, (scale2.max - v) / range2)) : 0.5;
-  if (group.type === "line") {
-    let segment = [];
-    values2.forEach((v, i2) => {
-      const x = xs[i2];
-      if (v === null || x === null || x === void 0) {
-        if (group.displayEmptyCellsAs === "gap" && segment.length) {
-          view.lines.push(segment);
-          segment = [];
-        }
-        return;
-      }
-      const point = { x: flip(x), y: yOf(v) };
-      segment.push(point);
-      const color = pointColor(group, v, i2, facts, colors, true);
-      if (color) view.markers.push({ ...point, color });
-    });
-    if (segment.length) view.lines.push(segment);
-  } else {
-    const slot = 1 / n;
-    const w = slot * (1 - COLUMN_GAP);
-    const base = yOf(Math.max(scale2.min, Math.min(scale2.max, 0)));
-    values2.forEach((v, i2) => {
-      const position = xs[i2];
-      if (v === null || position === null || position === void 0) return;
-      if (v === 0) return;
-      let top;
-      let bottom;
-      if (group.type === "stacked") [top, bottom] = v > 0 ? [0, 0.5] : [0.5, 1];
-      else if (!range2) [top, bottom] = [0, 1];
-      else [top, bottom] = [Math.min(base, yOf(v)), Math.max(base, yOf(v))];
-      const centre = flip(slot / 2 + position * (1 - slot));
-      const color = pointColor(group, v, i2, facts, colors, false) ?? view.color;
-      view.columns.push({ x: centre - w / 2, y: top, w, h: bottom - top, color });
-    });
-  }
-  if (group.type === "stacked") {
-    if (group.displayXAxis) view.axis = { y: 0.5, color: colors.colorAxis };
-  } else if (group.displayXAxis && range2 && scale2.min <= 0 && scale2.max >= 0)
-    view.axis = { y: yOf(0), color: colors.colorAxis };
-  return view;
+    () => {
+      sheet.merges = sheet.merges.filter((m) => !rangesIntersect(m, r));
+    },
+    { sheet: s, ranges: [r] }
+  );
 }
 
-// xlsx/layout/sparkline-data.ts
-var MAX_POINTS = 1e4;
-var hostIndex = /* @__PURE__ */ new WeakMap();
-function hosts(sheet) {
-  const groups = sheetSparklineGroups(sheet);
-  let index2 = hostIndex.get(groups);
-  if (!index2) {
-    index2 = /* @__PURE__ */ new Map();
-    for (const group of groups)
-      group.sparklines.forEach((line2, i2) => {
-        const key = cellKey(line2.host.start.row, line2.host.start.col);
-        if (!index2.has(key)) index2.set(key, { group, index: i2 });
-      });
-    hostIndex.set(groups, index2);
-  }
-  return index2;
+// xlsx/layout/style-view.ts
+var BLACK = "#000000";
+var WHITE = "#FFFFFF";
+var PX_PER_PT = 96 / 72;
+function mergeFont(base, font) {
+  if (!font) return base;
+  const out = { ...base };
+  for (const [key, value2] of Object.entries(font))
+    if (value2 !== void 0) out[key] = value2;
+  return out;
 }
-function hasSparklineAt(sheet, row2, col) {
-  return hosts(sheet).has(cellKey(row2, col));
+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 = {
+    family,
+    sizePx: (font.size && font.size > 0 ? font.size : 11) * PX_PER_PT,
+    bold: font.bold === true,
+    italic: font.italic === true,
+    strike: font.strike === true,
+    color: resolveColor(font.color, theme2, BLACK) ?? BLACK
+  };
+  if (font.underline)
+    view.underline = font.underline === "double" || font.underline === "doubleAccounting" ? "double" : "single";
+  if (font.vertAlign === "superscript") view.vertAlign = "super";
+  else if (font.vertAlign === "subscript") view.vertAlign = "sub";
+  return view;
 }
-function resolveSparklineRange(workbook, sheet, formula) {
-  const ref = formula.trim().replace(/^=/, "");
-  const bang = ref.lastIndexOf("!");
-  let target2 = sheet;
-  if (bang >= 0) {
-    const raw = ref.slice(0, bang);
-    const name = /^'.*'$/.test(raw) ? raw.slice(1, -1).replace(/''/g, "'") : raw;
-    target2 = sheetByName(workbook, name);
+function fillView(fill, theme2, differential = false) {
+  if (!fill) return void 0;
+  if (fill.type === "gradient") {
+    const stops = [...fill.stops].sort((a, b) => a.position - b.position).map((stop) => `${resolveColor(stop.color, theme2, WHITE)} ${round2(stop.position * 100)}%`);
+    if (stops.length === 0) return void 0;
+    if (stops.length === 1) stops.push(stops[0] ?? WHITE);
+    const css = fill.gradient === "path" ? `radial-gradient(circle, ${stops.join(", ")})` : `linear-gradient(${round2(((fill.degree ?? 0) + 90) % 360)}deg, ${stops.join(", ")})`;
+    return { gradient: css };
   }
-  const range2 = parseRange(ref.slice(bang + 1).replace(/\$/g, ""));
-  return target2 && range2 ? { sheet: target2, range: normalizeRange(range2) } : void 0;
-}
-var rowHidden = (sheet, row2) => sheet.rowInfo.get(row2)?.hidden === true;
-var colHidden = (sheet, col) => sheet.columns.some((c) => c.hidden === true && col >= c.min && col <= c.max);
-function readSparklineValues(sheet, range2, displayHidden) {
-  let endRow = range2.end.row;
-  if (endRow - range2.start.row >= MAX_POINTS) {
-    let lastRow = range2.start.row;
-    for (const row2 of sheet.rows.keys()) if (row2 > lastRow) lastRow = row2;
-    endRow = Math.min(endRow, lastRow);
+  if (fill.pattern === "none") {
+    if (differential && fill.bgColor)
+      return { background: resolveColor(fill.bgColor, theme2, WHITE) ?? WHITE };
+    return void 0;
   }
-  const out = [];
-  for (let row2 = range2.start.row; row2 <= endRow && out.length < MAX_POINTS; row2++) {
-    if (!displayHidden && rowHidden(sheet, row2)) continue;
-    for (let col = range2.start.col; col <= range2.end.col && out.length < MAX_POINTS; col++) {
-      if (!displayHidden && colHidden(sheet, col)) continue;
-      const value2 = getCell(sheet, row2, col)?.value;
-      out.push(typeof value2 === "number" && Number.isFinite(value2) ? value2 : null);
-    }
+  if (fill.pattern === "solid") {
+    const color = differential ? fill.bgColor ?? fill.fgColor : fill.fgColor ?? fill.bgColor;
+    return { background: resolveColor(color, theme2, BLACK) ?? BLACK };
   }
-  return out;
+  return {
+    pattern: fill.pattern,
+    fg: resolveColor(fill.fgColor, theme2, BLACK) ?? BLACK,
+    bg: resolveColor(fill.bgColor, theme2, WHITE) ?? WHITE
+  };
 }
-function groupData(workbook, sheet, group) {
-  const dateRange = group.dateAxis && group.dateFormula;
-  const dates = dateRange ? resolveSparklineRange(workbook, sheet, dateRange) : void 0;
-  const dateValues = dates ? readSparklineValues(dates.sheet, dates.range, group.displayHidden) : void 0;
-  return group.sparklines.map((line2) => {
-    const source = line2.formula ? resolveSparklineRange(workbook, sheet, line2.formula) : void 0;
-    const values2 = source ? readSparklineValues(source.sheet, source.range, group.displayHidden) : [];
-    return dateValues ? { values: values2, dates: dateValues } : { values: values2 };
-  });
+var round2 = (n) => Math.round(n * 100) / 100;
+var BORDER_STYLES = {
+  hair: { widthPx: 1, style: "dotted" },
+  thin: { widthPx: 1, style: "solid" },
+  dotted: { widthPx: 1, style: "dotted" },
+  dashed: { widthPx: 1, style: "dashed" },
+  dashDot: { widthPx: 1, style: "dashed" },
+  dashDotDot: { widthPx: 1, style: "dashed" },
+  medium: { widthPx: 2, style: "solid" },
+  mediumDashed: { widthPx: 2, style: "dashed" },
+  mediumDashDot: { widthPx: 2, style: "dashed" },
+  mediumDashDotDot: { widthPx: 2, style: "dashed" },
+  slantDashDot: { widthPx: 2, style: "dashed" },
+  thick: { widthPx: 3, style: "solid" },
+  double: { widthPx: 3, style: "double" }
+};
+function edgeView(edge, theme2) {
+  if (!edge) return void 0;
+  const style2 = BORDER_STYLES[edge.style];
+  if (!style2) return void 0;
+  return { ...style2, color: resolveColor(edge.color, theme2, BLACK) ?? BLACK };
 }
-function sparklineViewAt(workbook, sheetIndex2, row2, col) {
-  const sheet = workbook.sheets[sheetIndex2];
-  if (!sheet) return void 0;
-  const entry = hosts(sheet).get(cellKey(row2, col));
-  if (!entry) return void 0;
-  const { group, index: index2 } = entry;
-  const needsGroup = group.minAxisType === "group" || group.maxAxisType === "group";
-  const data = needsGroup ? groupData(workbook, sheet, group) : groupData(workbook, sheet, { ...group, sparklines: [group.sparklines[index2]] });
-  const at = needsGroup ? index2 : 0;
-  return sparklineView(
-    group,
-    data[at] ?? { values: [] },
-    sparklineScale(group, data, at),
-    workbook.theme
-  );
+function mergeBorder(base, border) {
+  if (!border) return base;
+  const out = { ...base };
+  for (const [key, value2] of Object.entries(border))
+    if (value2 !== void 0) out[key] = value2;
+  return out;
+}
+function bordersView(border, theme2) {
+  const out = {};
+  const set = (key, edge) => {
+    const view = edgeView(edge, theme2);
+    if (view) out[key] = view;
+  };
+  set("top", border.top);
+  set("right", border.right);
+  set("bottom", border.bottom);
+  set("left", border.left);
+  if (border.diagonalUp) set("diagonalUp", border.diagonal);
+  if (border.diagonalDown) set("diagonalDown", border.diagonal);
+  return out;
 }
 
 // xlsx/layout/units.ts
@@ -20880,7 +21913,7 @@ function cellView(workbook, sheetIndex2, row2, col, cf, options = {}) {
     indentPx: indentable ? (alignment.indent ?? 0) * (options.indentPx ?? INDENT_PX_PER_LEVEL) : 0,
     rotation,
     isNumber: isNumber2,
-    overflow: (formulaText !== void 0 || typeof value2 === "string" && value2 !== "") && !wrap2 && !shrink && rotation === 0 && !vertical2 && hAlign !== "fill" && !sheet.merges.some((m) => rangeContains(m, { row: row2, col })),
+    overflow: (formulaText !== void 0 || typeof value2 === "string" && value2 !== "") && !wrap2 && !shrink && rotation === 0 && !vertical2 && hAlign !== "fill" && !(options.merged ?? sheet.merges.some((m) => rangeContains(m, { row: row2, col }))),
     hasComment: sheet.comments.some((c) => c.address.row === row2 && c.address.col === col),
     hasHyperlink: false,
     validationList: sheet.dataValidations.some(
@@ -21245,6 +22278,12 @@ function deleteSheet(ctx, index2) {
   const sheet = sheetAt(workbook, index2);
   if (sheet.state === "visible" && visibleCount(workbook) <= 1)
     throw new Error("A workbook must contain at least one visible sheet.");
+  if (workbook.sheets.some(
+    (other) => other !== sheet && other.pivotTables?.some(
+      (pivot) => deleteSheetInFormula(pivot.source, sheet.name, []) !== pivot.source
+    )
+  ))
+    throw new Error("Delete dependent PivotTables before deleting their source worksheet.");
   ctx.run(
     "Delete sheet",
     "sheets",
@@ -21348,6 +22387,17 @@ function duplicateSheet(ctx, index2) {
       copy2.name = copyName(workbook, sheet.name);
       copy2.sheetId = nextSheetId(workbook);
       delete copy2.partName;
+      const pivotNames = reservedPivotNames(workbook);
+      for (const pivot of copy2.pivotTables ?? []) {
+        let suffix = 2;
+        while (pivotNames.has(`${pivot.name}_${suffix}`.toLowerCase())) suffix++;
+        pivot.name = `${pivot.name}_${suffix}`;
+        pivotNames.add(pivot.name.toLowerCase());
+        delete pivot.partName;
+        delete pivot.cacheId;
+        delete pivot.sourceXml;
+        pivot.dirty = true;
+      }
       let nextTableId = Math.max(0, ...workbook.sheets.flatMap((s) => s.tables.map((t) => t.id))) + 1;
       const used = /* @__PURE__ */ new Set();
       const renames = [];
@@ -21359,13 +22409,14 @@ function duplicateSheet(ctx, index2) {
         delete next.partName;
         return next;
       });
-      if (renames.length)
-        rewriteSheetFormulas(
-          copy2,
-          (formula) => renames.reduce((f6, [from, to]) => renameTableInFormula(f6, from, to), formula)
-        );
+      const rewrite = (formula) => renames.reduce(
+        (f6, [from, to]) => renameTableInFormula(f6, from, to),
+        renameSheetInFormula(formula, sheet.name, copy2.name)
+      );
+      rewriteSheetFormulas(copy2, rewrite);
       for (const drawing of copy2.drawings) if (drawing.kind === "chart") delete drawing.partName;
       const copiedNames = namesForCopy(workbook, index2, sheet.name, copy2.name);
+      for (const name of copiedNames) name.formula = rewrite(name.formula);
       workbook.sheets.splice(at, 0, copy2);
       remapSheets(workbook, (i2) => i2 >= at ? i2 + 1 : i2);
       for (const n of copiedNames) workbook.definedNames.push({ ...n, localSheet: at });
@@ -21423,6 +22474,8 @@ function createTable(ctx, s, range2, hasHeader, styleName = "TableStyleMedium2")
   if (r.start.row === r.end.row && r.start.col === r.end.col) r = currentRegion(sheet, r.start);
   if (sheet.tables.some((t) => rangesIntersect(t.range, r)))
     throw new Error("A table cannot overlap another table.");
+  if (sheet.pivotTables?.some((pivot) => rangesIntersect(pivot.location, r)))
+    throw new Error("A table cannot overlap a PivotTable.");
   if (sheet.merges.some((m) => rangesIntersect(m, r)))
     throw new Error("A table cannot contain merged cells.");
   return ctx.run(
@@ -21649,68 +22702,6 @@ function failure(dv) {
   return result2;
 }
 
-// xlsx/edit/view.ts
-function setFreeze(ctx, s, freeze) {
-  const sheet = sheetAt(ctx.workbook, s);
-  const next = freeze && (freeze.rows > 0 || freeze.cols > 0) ? { rows: Math.max(0, freeze.rows), cols: Math.max(0, freeze.cols) } : void 0;
-  ctx.run(
-    next ? "Freeze panes" : "Unfreeze panes",
-    "view",
-    [{ kind: "sheet", sheet: s }],
-    () => {
-      if (next) sheet.view.freeze = next;
-      else delete sheet.view.freeze;
-    },
-    { sheet: s, structural: true }
-  );
-}
-function setSheetView(ctx, s, patch) {
-  const sheet = sheetAt(ctx.workbook, s);
-  ctx.run(
-    "Sheet view",
-    "view",
-    [{ kind: "sheet", sheet: s }],
-    () => {
-      const view = { ...sheet.view, ...structuredClone(patch) };
-      for (const key of Object.keys(view))
-        if (view[key] === void 0) delete view[key];
-      if (patch.zoom !== void 0) view.zoom = Math.max(10, Math.min(400, Math.round(patch.zoom)));
-      sheet.view = view;
-    },
-    { sheet: s, structural: patch.zoom !== void 0 || "freeze" in patch }
-  );
-}
-var NAME_PATTERN = /^[A-Za-z_\\][A-Za-z0-9_.\\?]*$/;
-function validateDefinedName(name) {
-  if (!name || name.length > 255) return "A name must have 1 to 255 characters.";
-  if (!NAME_PATTERN.test(name))
-    return "A name must start with a letter, underscore or backslash and contain no spaces.";
-  if (parseAddress(name) || /^[RrCc]$/.test(name) || /^R\d*C\d*$/i.test(name))
-    return "A name cannot look like a cell reference.";
-  return void 0;
-}
-var sameName = (a, name, localSheet) => a.name.toLowerCase() === name.toLowerCase() && a.localSheet === localSheet;
-function setDefinedName(ctx, name) {
-  const problem = name.name.startsWith("_xlnm.") ? void 0 : validateDefinedName(name.name);
-  if (problem) throw new Error(problem);
-  if (name.localSheet !== void 0) sheetAt(ctx.workbook, name.localSheet);
-  const entry = structuredClone(name);
-  entry.formula = entry.formula.replace(/^=/, "");
-  ctx.run("Define name", "names", [{ kind: "meta" }], () => {
-    const { definedNames } = ctx.workbook;
-    const index2 = definedNames.findIndex((n) => sameName(n, name.name, name.localSheet));
-    if (index2 >= 0) definedNames[index2] = entry;
-    else definedNames.push(entry);
-  });
-}
-function deleteDefinedName(ctx, name, localSheet) {
-  const index2 = ctx.workbook.definedNames.findIndex((n) => sameName(n, name, localSheet));
-  if (index2 < 0) return;
-  ctx.run("Delete name", "names", [{ kind: "meta" }], () => {
-    ctx.workbook.definedNames.splice(index2, 1);
-  });
-}
-
 // xlsx/edit/session.ts
 function createEditSession(workbook, options = {}) {
   const calc = createCalcEngine(workbook);
@@ -21723,8 +22714,8 @@ function createEditSession(workbook, options = {}) {
   };
   const calculator = new SessionCalculator(workbook, calc, autoRecalc);
   const recalc = (step, mode = "apply") => calculator.afterStep(step, mode);
-  const begin = (label2, kind, info) => {
-    const step = { label: label2, entries: [], structural: info.structural ?? false };
+  const begin = (label3, kind, info) => {
+    const step = { label: label3, entries: [], structural: info.structural ?? false };
     if (info.calc) step.calc = info.calc;
     return { step, kind, sheet: info.sheet, ranges: [...info.ranges ?? []] };
   };
@@ -21748,9 +22739,18 @@ function createEditSession(workbook, options = {}) {
     }
     current.step.entries.length = from;
   };
-  const run = (label2, kind, scopes, fn, info = {}) => {
+  const run = (label3, kind, scopes, fn, info = {}) => {
+    if (kind === "cells") {
+      for (const scope of scopes)
+        if (scope.kind === "cells" && workbook.sheets[scope.sheet]?.pivotTables?.some(
+          (pivot) => scope.ranges.some((range2) => rangesIntersect(range2, pivot.location))
+        ))
+          throw new Error(
+            "A PivotTable result cannot be edited directly. Refresh or remove the PivotTable instead."
+          );
+    }
     const outer = !open;
-    const current = open ?? begin(label2, kind, info);
+    const current = open ?? begin(label3, kind, info);
     if (!outer) {
       delete current.step.calc;
       if (info.structural) current.step.structural = true;
@@ -21816,7 +22816,7 @@ function createEditSession(workbook, options = {}) {
     setCellValue: (s, r, c, value2) => setCellValue(ctx, s, r, c, value2),
     setRangeValues: (s, at, rows2) => setRangeValues(ctx, s, at, rows2),
     clearRange: (s, range2, what) => clearRange(ctx, s, range2, what),
-    applyStyle: (s, ranges, patch) => applyStyle(ctx, s, ranges, patch),
+    applyStyle: (s, ranges, patch2) => applyStyle(ctx, s, ranges, patch2),
     setBorders: (s, range2, preset, edge) => setBorders(ctx, s, range2, preset, edge),
     insertRows: (s, at, count2) => insertRows(ctx, s, at, count2),
     deleteRows: (s, at, count2) => deleteRows(ctx, s, at, count2),
@@ -21854,24 +22854,34 @@ function createEditSession(workbook, options = {}) {
     filterColumn: (s, col, vals) => filterColumn(ctx, s, col, vals),
     sortByColumn: (s, col, descending) => sortByColumn(ctx, s, col, descending ?? false),
     createTable: (s, range2, hasHeader, styleName) => createTable(ctx, s, range2, hasHeader, styleName),
-    setSheetView: (s, patch) => setSheetView(ctx, s, patch),
+    setSheetView: (s, patch2) => setSheetView(ctx, s, patch2),
     setDefinedName: (name) => setDefinedName(ctx, name),
     deleteDefinedName: (name, localSheet) => deleteDefinedName(ctx, name, localSheet),
     setDrawingAnchor: (s, index2, anchor) => setDrawingAnchor(ctx, s, index2, anchor),
+    createPivotTable: (s, destination, options2) => createPivotTable(ctx, s, destination, options2),
+    refreshPivotTable: (s, name, patch2) => refreshPivotTable(ctx, s, name, patch2),
+    deletePivotTable: (s, name) => deletePivotTable(ctx, s, name),
     deleteDrawing: (s, index2) => deleteDrawing(ctx, s, index2),
+    createSparklineGroup: (s, source, locations, patch2) => createSparklineGroup(ctx, s, source, locations, patch2),
+    setSparklineGroups: (s, ranges, patch2) => setSparklineGroups(ctx, s, ranges, patch2),
+    setSparklineDateRange: (s, ranges, source) => setSparklineDateRange(ctx, s, ranges, source),
+    deleteSparklines: (s, ranges, wholeGroups) => deleteSparklines(ctx, s, ranges, wholeGroups),
     addChart: (s, chart) => addChart(ctx, s, chart),
-    updateChart: (s, index2, patch) => updateChart(ctx, s, index2, patch),
+    updateChart: (s, index2, patch2) => updateChart(ctx, s, index2, patch2),
     addImage: (s, bytes, type, anchor, name) => addImage(ctx, s, bytes, type, anchor, name),
     replaceConditionalFormat: (s, index2, cf) => replaceConditionalFormat(ctx, s, index2, cf),
     removeConditionalFormat: (s, index2) => removeConditionalFormat(ctx, s, index2),
     setConditionalRulePriority: (s, f6, r, priority) => setConditionalRulePriority(ctx, s, f6, r, priority),
     moveConditionalRule: (s, f6, r, direction) => moveConditionalRule(ctx, s, f6, r, direction),
-    updateTable: (s, table2, patch) => updateTable(ctx, s, table2, patch),
+    updateTable: (s, table2, patch2) => updateTable(ctx, s, table2, patch2),
     resizeTable: (s, table2, range2) => resizeTable(ctx, s, table2, range2),
     convertTableToRange: (s, table2) => convertTableToRange(ctx, s, table2),
     applyCellStyle: (s, ranges, name) => applyCellStyle(ctx, s, ranges, name),
-    setPageSetup: (s, patch) => setPageSetup(ctx, s, patch),
-    setPrintOptions: (s, patch) => setPrintOptions(ctx, s, patch),
+    setPageSetup: (s, patch2) => setPageSetup(ctx, s, patch2),
+    setPageBreak: (s, axis, before, present) => setPageBreak(ctx, s, axis, before, present),
+    resetPageBreaks: (s) => resetPageBreaks(ctx, s),
+    setPrintTitles: (s, patch2) => setPrintTitles(ctx, s, patch2),
+    setPrintOptions: (s, patch2) => setPrintOptions(ctx, s, patch2),
     setSheetProtection: (s, p, password) => setSheetProtection(ctx, s, p, password),
     setWorkbookProtection: (locked, password) => setWorkbookProtection(ctx, locked, password),
     groupRows: (s, from, to) => groupRows(ctx, s, from, to),
@@ -21881,7 +22891,7 @@ function createEditSession(workbook, options = {}) {
     setDefaultColumnWidth: (s, width) => setDefaultColumnWidth(ctx, s, width),
     removeDuplicates: (s, range2, cols, hasHeader) => removeDuplicates(ctx, s, range2, cols, hasHeader),
     setCalcMode: (mode) => setCalcMode(ctx, mode),
-    setDocumentProperties: (patch) => setDocumentProperties(ctx, patch),
+    setDocumentProperties: (patch2) => setDocumentProperties(ctx, patch2),
     setAutoRecalc: (enabled) => setCalcMode(ctx, enabled ? "auto" : "manual"),
     autoRecalc: () => autoRecalc && calcModeOf(workbook) === "auto",
     calculateNow(options2) {
@@ -21896,12 +22906,12 @@ function createEditSession(workbook, options = {}) {
     validate: (s, r, c, value2) => validateCellInput(workbook, s, r, c, value2, {
       evaluate: (formula, at) => calc.evaluate(formula, at)
     }),
-    batch(label2, fn) {
+    batch(label3, fn) {
       if (open) {
         fn();
         return;
       }
-      const current = begin(label2, "batch", {});
+      const current = begin(label3, "batch", {});
       open = current;
       try {
         fn();
@@ -22856,21 +23866,21 @@ function stepFontSize(size, grow) {
   if (grow) return FONT_SIZES.find((s) => s > size) ?? Math.min(409, size + 10);
   return [...FONT_SIZES].reverse().find((s) => s < size) ?? Math.max(1, size - 1);
 }
-var style = (ctx, patch) => {
-  withTarget(ctx, (t) => t.session.applyStyle(t.sheet, t.ranges, patch));
+var style = (ctx, patch2) => {
+  withTarget(ctx, (t) => t.session.applyStyle(t.sheet, t.ranges, patch2));
 };
 function pickColor(arg) {
   if (arg && typeof arg === "object" && !arg.auto) return arg;
   return null;
 }
-var toggle = (id, label2, glyph, shortcut, read, patch) => editing({
+var toggle = (id, label3, glyph, shortcut, read, patch2) => editing({
   id,
-  label: label2,
+  label: label3,
   icon: icon(glyph),
   shortcut,
   lock: "formatCells",
   checked: read,
-  run: (ctx) => style(ctx, patch(!read(ctx)))
+  run: (ctx) => style(ctx, patch2(!read(ctx)))
 });
 var BORDER_PRESETS = [
   ["bottom", "Bottom Border", "borderBottom"],
@@ -23050,10 +24060,10 @@ var mergedAtActive = (ctx) => {
   const t = target(ctx);
   return !!t && t.ws.merges.some((m) => rangesIntersect(m, t.range));
 };
-function mergeCommand(id, label2, mode) {
+function mergeCommand(id, label3, mode) {
   return editing({
     id,
-    label: label2,
+    label: label3,
     icon: icon("mergeCenter"),
     lock: "formatCells",
     ...mode === "center" ? { checked: mergedAtActive } : {},
@@ -23068,30 +24078,30 @@ function mergeCommand(id, label2, mode) {
       }
       if (t.ranges.some((range2) => mergeWouldDiscard(t.ws, range2, mode))) {
         const ok = await ctx.dialogs.open("confirm", {
-          heading: label2,
+          heading: label3,
           message: "Merging cells only keeps the upper-left value and discards other values."
         });
         if (ok !== true) return;
         if (ctx.session() !== t.session || ctx.readOnly()) return;
       }
-      t.session.batch(label2, () => {
+      t.session.batch(label3, () => {
         for (const range2 of t.ranges) t.session.merge(t.sheet, range2, mode);
       });
     }
   });
 }
 function alignmentCommands() {
-  const valign = (id, label2, value2, glyph) => editing({
+  const valign = (id, label3, value2, glyph) => editing({
     id,
-    label: label2,
+    label: label3,
     icon: icon(glyph),
     lock: "formatCells",
     checked: (ctx) => vertical(ctx) === value2,
     run: (ctx) => style(ctx, { alignment: { vertical: value2 === "bottom" ? UNSET : value2 } })
   });
-  const halign = (id, label2, value2, glyph) => editing({
+  const halign = (id, label3, value2, glyph) => editing({
     id,
-    label: label2,
+    label: label3,
     icon: icon(glyph),
     lock: "formatCells",
     checked: (ctx) => horizontal(ctx) === value2,
@@ -24475,6 +25485,24 @@ var MESSAGE_STRINGS = {
 
 // xlsx/ui/commands/i18n/navigation.ts
 var NAVIGATION_STRINGS = {
+  "Sparklines (create, format and clear)": [
+    "Graphiques sparkline (cr\xE9ation, mise en forme et suppression)",
+    "Sparklines (erstellen, formatieren und l\xF6schen)",
+    "Minigr\xE1ficos (crear, dar formato y borrar)",
+    "\u8FF7\u4F60\u56FE\uFF08\u521B\u5EFA\u3001\u683C\u5F0F\u8BBE\u7F6E\u548C\u6E05\u9664\uFF09"
+  ],
+  "Worksheet-range PivotTables (one row field, optional column field and one value field)": [
+    "Tableaux crois\xE9s dynamiques de plages (un champ de ligne, un champ de colonne facultatif et un champ de valeur)",
+    "PivotTables aus Arbeitsblattbereichen (ein Zeilenfeld, optionales Spaltenfeld und ein Wertfeld)",
+    "Tablas din\xE1micas de rangos (un campo de fila, columna opcional y un valor)",
+    "\u5DE5\u4F5C\u8868\u533A\u57DF\u6570\u636E\u900F\u89C6\u8868\uFF08\u4E00\u4E2A\u884C\u5B57\u6BB5\u3001\u53EF\u9009\u5217\u5B57\u6BB5\u548C\u4E00\u4E2A\u503C\u5B57\u6BB5\uFF09"
+  ],
+  "Advanced PivotTable layouts, grouping and external data sources (preserved)": [
+    "Dispositions avanc\xE9es, regroupements et sources externes de tableaux crois\xE9s dynamiques (conserv\xE9s)",
+    "Erweiterte PivotTable-Layouts, Gruppierung und externe Datenquellen (erhalten)",
+    "Dise\xF1os avanzados, agrupaci\xF3n y fuentes externas de tablas din\xE1micas (conservados)",
+    "\u9AD8\u7EA7\u6570\u636E\u900F\u89C6\u8868\u5E03\u5C40\u3001\u5206\u7EC4\u548C\u5916\u90E8\u6570\u636E\u6E90\uFF08\u4FDD\u7559\uFF09"
+  ],
   OK: ["OK", "OK", "Aceptar", "\u786E\u5B9A"],
   Cancel: ["Annuler", "Abbrechen", "Cancelar", "\u53D6\u6D88"],
   Close: ["Fermer", "Schlie\xDFen", "Cerrar", "\u5173\u95ED"],
@@ -26611,6 +27639,149 @@ var RIBBON_TAB_STRINGS = {
 
 // xlsx/ui/commands/i18n/tools.ts
 var TOOLS_STRINGS = {
+  Bold: RIBBON_HOME_STRINGS.Bold,
+  Italic: RIBBON_HOME_STRINGS.Italic,
+  Underline: RIBBON_HOME_STRINGS.Underline,
+  Strikethrough: RIBBON_HOME_STRINGS.Strikethrough,
+  "Insert Formatting": [
+    "Ins\xE9rer une mise en forme",
+    "Formatierung einf\xFCgen",
+    "Insertar formato",
+    "\u63D2\u5165\u683C\u5F0F"
+  ],
+  'Formatting: &B bold, &I italic, &U underline, &S strike, &18 font size, &KFF0000 RGB color, &"Arial,Regular" font.': [
+    'Format : &B gras, &I italique, &U soulign\xE9, &S barr\xE9, &18 taille, &KFF0000 couleur RVB, &"Arial,Regular" police.',
+    'Format: &B fett, &I kursiv, &U unterstrichen, &S durchgestrichen, &18 Schriftgr\xF6\xDFe, &KFF0000 RGB-Farbe, &"Arial,Regular" Schriftart.',
+    'Formato: &B negrita, &I cursiva, &U subrayado, &S tachado, &18 tama\xF1o, &KFF0000 color RGB, &"Arial,Regular" fuente.',
+    '\u683C\u5F0F\uFF1A&B \u7C97\u4F53\u3001&I \u659C\u4F53\u3001&U \u4E0B\u5212\u7EBF\u3001&S \u5220\u9664\u7EBF\u3001&18 \u5B57\u53F7\u3001&KFF0000 RGB \u989C\u8272\u3001&"Arial,Regular" \u5B57\u4F53\u3002'
+  ],
+  "Date Range (optional):": [
+    "Plage de dates (facultative) :",
+    "Datumsbereich (optional):",
+    "Rango de fechas (opcional):",
+    "\u65E5\u671F\u8303\u56F4\uFF08\u53EF\u9009\uFF09\uFF1A"
+  ],
+  "Leave the date range empty for a general axis.": [
+    "Laissez la plage de dates vide pour un axe g\xE9n\xE9ral.",
+    "F\xFCr eine allgemeine Achse den Datumsbereich leer lassen.",
+    "Deje vac\xEDo el rango de fechas para un eje general.",
+    "\u5C06\u65E5\u671F\u8303\u56F4\u7559\u7A7A\u4EE5\u4F7F\u7528\u5E38\u89C4\u5750\u6807\u8F74\u3002"
+  ],
+  Time: ["Heure", "Zeit", "Hora", "\u65F6\u95F4"],
+  "First Page Header:": [
+    "En-t\xEAte de premi\xE8re page :",
+    "Kopfzeile der ersten Seite:",
+    "Encabezado de primera p\xE1gina:",
+    "\u9996\u9875\u9875\u7709\uFF1A"
+  ],
+  "First Page Footer:": [
+    "Pied de premi\xE8re page :",
+    "Fu\xDFzeile der ersten Seite:",
+    "Pie de primera p\xE1gina:",
+    "\u9996\u9875\u9875\u811A\uFF1A"
+  ],
+  "Even Page Header:": [
+    "En-t\xEAte des pages paires :",
+    "Kopfzeile gerader Seiten:",
+    "Encabezado de p\xE1ginas pares:",
+    "\u5076\u6570\u9875\u9875\u7709\uFF1A"
+  ],
+  "Even Page Footer:": [
+    "Pied des pages paires :",
+    "Fu\xDFzeile gerader Seiten:",
+    "Pie de p\xE1ginas pares:",
+    "\u5076\u6570\u9875\u9875\u811A\uFF1A"
+  ],
+  "Different first page": [
+    "Premi\xE8re page diff\xE9rente",
+    "Erste Seite anders",
+    "Primera p\xE1gina diferente",
+    "\u9996\u9875\u4E0D\u540C"
+  ],
+  "Different odd and even pages": [
+    "Pages paires et impaires diff\xE9rentes",
+    "Gerade und ungerade Seiten unterschiedlich",
+    "P\xE1ginas pares e impares diferentes",
+    "\u5947\u5076\u9875\u4E0D\u540C"
+  ],
+  "Scale header and footer with document": [
+    "Mettre l\u2019en-t\xEAte et le pied \xE0 l\u2019\xE9chelle du document",
+    "Kopf- und Fu\xDFzeile mit Dokument skalieren",
+    "Escalar encabezado y pie con el documento",
+    "\u968F\u6587\u6863\u7F29\u653E\u9875\u7709\u548C\u9875\u811A"
+  ],
+  "Align header and footer with margins": [
+    "Aligner l\u2019en-t\xEAte et le pied sur les marges",
+    "Kopf- und Fu\xDFzeile an R\xE4ndern ausrichten",
+    "Alinear encabezado y pie con los m\xE1rgenes",
+    "\u5C06\u9875\u7709\u548C\u9875\u811A\u4E0E\u9875\u8FB9\u8DDD\u5BF9\u9F50"
+  ],
+  "Insert Field": ["Ins\xE9rer un champ", "Feld einf\xFCgen", "Insertar campo", "\u63D2\u5165\u5B57\u6BB5"],
+  "Page Number": ["Num\xE9ro de page", "Seitenzahl", "N\xFAmero de p\xE1gina", "\u9875\u7801"],
+  "Total Pages": ["Nombre de pages", "Gesamtseitenzahl", "Total de p\xE1ginas", "\u603B\u9875\u6570"],
+  "Sheet Name": ["Nom de feuille", "Blattname", "Nombre de hoja", "\u5DE5\u4F5C\u8868\u540D\u79F0"],
+  "File Name": ["Nom de fichier", "Dateiname", "Nombre de archivo", "\u6587\u4EF6\u540D"],
+  "Rows to repeat at top": [
+    "Lignes \xE0 r\xE9p\xE9ter en haut",
+    "Wiederholungszeilen oben",
+    "Filas a repetir arriba",
+    "\u9876\u7AEF\u6807\u9898\u884C"
+  ],
+  "Columns to repeat at left": [
+    "Colonnes \xE0 r\xE9p\xE9ter \xE0 gauche",
+    "Wiederholungsspalten links",
+    "Columnas a repetir a la izquierda",
+    "\u5DE6\u7AEF\u6807\u9898\u5217"
+  ],
+  "Use first page number": [
+    "Utiliser le premier num\xE9ro de page",
+    "Erste Seitenzahl verwenden",
+    "Usar primer n\xFAmero de p\xE1gina",
+    "\u4F7F\u7528\u8D77\u59CB\u9875\u7801"
+  ],
+  "First page number": [
+    "Premier num\xE9ro de page",
+    "Erste Seitenzahl",
+    "Primer n\xFAmero de p\xE1gina",
+    "\u8D77\u59CB\u9875\u7801"
+  ],
+  "Enter a first page number between 0 and 32767.": [
+    "Entrez un premier num\xE9ro entre 0 et 32767.",
+    "Geben Sie eine erste Seitenzahl zwischen 0 und 32767 ein.",
+    "Introduzca un primer n\xFAmero entre 0 y 32767.",
+    "\u8BF7\u8F93\u5165 0 \u5230 32767 \u4E4B\u95F4\u7684\u8D77\u59CB\u9875\u7801\u3002"
+  ],
+  "Print titles must be whole rows or whole columns.": [
+    "Les titres doivent \xEAtre des lignes ou colonnes enti\xE8res.",
+    "Drucktitel m\xFCssen ganze Zeilen oder Spalten sein.",
+    "Los t\xEDtulos deben ser filas o columnas completas.",
+    "\u6253\u5370\u6807\u9898\u5FC5\u987B\u4E3A\u6574\u884C\u6216\u6574\u5217\u3002"
+  ],
+  "Existing print titles are unsupported. Changing a title range replaces them; leaving the fields unchanged preserves them.": [
+    "Les titres existants ne sont pas pris en charge. Modifier une plage les remplace ; conserver les champs les pr\xE9serve.",
+    "Vorhandene Drucktitel werden nicht unterst\xFCtzt. Eine Bereichs\xE4nderung ersetzt sie; unver\xE4nderte Felder bewahren sie.",
+    "Los t\xEDtulos existentes no son compatibles. Cambiar un rango los reemplaza; dejar los campos sin cambios los conserva.",
+    "\u4E0D\u652F\u6301\u73B0\u6709\u6253\u5370\u6807\u9898\u3002\u66F4\u6539\u6807\u9898\u533A\u57DF\u4F1A\u66FF\u6362\u5B83\u4EEC\uFF1B\u4FDD\u6301\u5B57\u6BB5\u4E0D\u53D8\u53EF\u4FDD\u7559\u5B83\u4EEC\u3002"
+  ],
+  "Use &L, &C and &R for sections. Fields: &P page, &N total pages, &A sheet, &F file, &D date, &T time. Use && for an ampersand. Unsupported formatting codes are preserved.": [
+    "Utilisez &L, &C et &R pour les sections. Champs : &P page, &N total, &A feuille, &F fichier, &D date, &T heure. && affiche une esperluette. Les codes non pris en charge sont conserv\xE9s.",
+    "Verwenden Sie &L, &C und &R f\xFCr Abschnitte. Felder: &P Seite, &N Gesamtseiten, &A Blatt, &F Datei, &D Datum, &T Zeit. && ergibt ein Und-Zeichen. Nicht unterst\xFCtzte Formatcodes bleiben erhalten.",
+    "Use &L, &C y &R para secciones. Campos: &P p\xE1gina, &N total, &A hoja, &F archivo, &D fecha, &T hora. && muestra un ampersand. Se conservan los c\xF3digos no compatibles.",
+    "\u4F7F\u7528 &L\u3001&C\u3001&R \u6307\u5B9A\u533A\u57DF\u3002\u5B57\u6BB5\uFF1A&P \u9875\u7801\u3001&N \u603B\u9875\u6570\u3001&A \u5DE5\u4F5C\u8868\u3001&F \u6587\u4EF6\u3001&D \u65E5\u671F\u3001&T \u65F6\u95F4\u3002&& \u8868\u793A &\u3002\u4FDD\u7559\u4E0D\u652F\u6301\u7684\u683C\u5F0F\u4EE3\u7801\u3002"
+  ],
+  "Page order": ["Ordre des pages", "Seitenreihenfolge", "Orden de p\xE1ginas", "\u9875\u5E8F"],
+  "Down, then over": [
+    "Vers le bas, puis \xE0 droite",
+    "Nach unten, dann nach rechts",
+    "Hacia abajo, luego a la derecha",
+    "\u5148\u5411\u4E0B\uFF0C\u518D\u5411\u53F3"
+  ],
+  "Over, then down": [
+    "\xC0 droite, puis vers le bas",
+    "Nach rechts, dann nach unten",
+    "A la derecha, luego hacia abajo",
+    "\u5148\u5411\u53F3\uFF0C\u518D\u5411\u4E0B"
+  ],
   // Insert Chart
   "Insert Chart": ["Ins\xE9rer un graphique", "Diagramm einf\xFCgen", "Insertar gr\xE1fico", "\u63D2\u5165\u56FE\u8868"],
   "Change Chart Type": [
@@ -27079,6 +28250,508 @@ var TOOLS_STRINGS = {
   ]
 };
 
+// xlsx/ui/commands/i18n/sparklines.ts
+var SPARKLINE_STRINGS = {
+  Mixed: ["Mixte", "Gemischt", "Mixto", "\u6DF7\u5408"],
+  "Only changed settings are applied.": [
+    "Seuls les param\xE8tres modifi\xE9s sont appliqu\xE9s.",
+    "Nur ge\xE4nderte Einstellungen werden angewendet.",
+    "Solo se aplica la configuraci\xF3n modificada.",
+    "\u4EC5\u5E94\u7528\u5DF2\u66F4\u6539\u7684\u8BBE\u7F6E\u3002"
+  ],
+  "Colors vary between selected groups.": [
+    "Les couleurs varient entre les groupes s\xE9lectionn\xE9s.",
+    "Die Farben der ausgew\xE4hlten Gruppen unterscheiden sich.",
+    "Los colores var\xEDan entre los grupos seleccionados.",
+    "\u9009\u5B9A\u7EC4\u7684\u989C\u8272\u4E0D\u540C\u3002"
+  ],
+  Markers: ["Marqueurs", "Markierungen", "Marcadores", "\u6807\u8BB0"],
+  Gaps: ["Espaces", "L\xFCcken", "Huecos", "\u95F4\u9699"],
+  Zero: ["Z\xE9ro", "Null", "Cero", "\u96F6"],
+  Axis: ["Axe", "Achse", "Eje", "\u5750\u6807\u8F74"],
+  "Sparklines (create, format and clear)": [
+    "Graphiques sparkline (cr\xE9er, mettre en forme et effacer)",
+    "Sparklines (erstellen, formatieren und l\xF6schen)",
+    "Minigr\xE1ficos (crear, dar formato y borrar)",
+    "\u8FF7\u4F60\u56FE\uFF08\u521B\u5EFA\u3001\u8BBE\u7F6E\u683C\u5F0F\u548C\u6E05\u9664\uFF09"
+  ],
+  "Charts and sparklines support editing; pivot tables, macros and other unsupported parts are kept in the file but not shown.": [
+    "Les graphiques et graphiques sparkline peuvent \xEAtre modifi\xE9s ; les tableaux crois\xE9s dynamiques, macros et autres \xE9l\xE9ments non pris en charge sont conserv\xE9s dans le fichier mais ne sont pas affich\xE9s.",
+    "Diagramme und Sparklines k\xF6nnen bearbeitet werden; Pivot-Tabellen, Makros und andere nicht unterst\xFCtzte Teile bleiben in der Datei erhalten, werden aber nicht angezeigt.",
+    "Los gr\xE1ficos y minigr\xE1ficos se pueden editar; las tablas din\xE1micas, macros y otras partes no compatibles se conservan en el archivo pero no se muestran.",
+    "\u56FE\u8868\u548C\u8FF7\u4F60\u56FE\u652F\u6301\u7F16\u8F91\uFF1B\u6570\u636E\u900F\u89C6\u8868\u3001\u5B8F\u548C\u5176\u4ED6\u4E0D\u652F\u6301\u7684\u90E8\u5206\u4FDD\u5B58\u5728\u6587\u4EF6\u4E2D\uFF0C\u4F46\u4E0D\u663E\u793A\u3002"
+  ],
+  Sparklines: ["Graphiques sparkline", "Sparklines", "Minigr\xE1ficos", "\u8FF7\u4F60\u56FE"],
+  "Line Sparkline": [
+    "Sparkline en courbe",
+    "Linien-Sparkline",
+    "Minigr\xE1fico de l\xEDnea",
+    "\u6298\u7EBF\u8FF7\u4F60\u56FE"
+  ],
+  "Column Sparkline": [
+    "Sparkline en colonnes",
+    "S\xE4ulen-Sparkline",
+    "Minigr\xE1fico de columna",
+    "\u67F1\u5F62\u8FF7\u4F60\u56FE"
+  ],
+  "Win/Loss Sparkline": [
+    "Sparkline gains/pertes",
+    "Gewinn/Verlust-Sparkline",
+    "Minigr\xE1fico de ganancias y p\xE9rdidas",
+    "\u76C8\u4E8F\u8FF7\u4F60\u56FE"
+  ],
+  "Win/Loss": ["Gains/pertes", "Gewinn/Verlust", "Ganancias y p\xE9rdidas", "\u76C8\u4E8F"],
+  "Create Sparklines": [
+    "Cr\xE9er des graphiques sparkline",
+    "Sparklines erstellen",
+    "Crear minigr\xE1ficos",
+    "\u521B\u5EFA\u8FF7\u4F60\u56FE"
+  ],
+  "Sparkline Settings": [
+    "Param\xE8tres des graphiques sparkline",
+    "Sparkline-Einstellungen",
+    "Configuraci\xF3n de minigr\xE1ficos",
+    "\u8FF7\u4F60\u56FE\u8BBE\u7F6E"
+  ],
+  "Data Range:": ["Plage de donn\xE9es :", "Datenbereich:", "Rango de datos:", "\u6570\u636E\u8303\u56F4\uFF1A"],
+  "Location Range:": [
+    "Plage d\u2019emplacement :",
+    "Positionsbereich:",
+    "Rango de ubicaci\xF3n:",
+    "\u4F4D\u7F6E\u8303\u56F4\uFF1A"
+  ],
+  "Sparkline Type:": [
+    "Type de sparkline :",
+    "Sparkline-Typ:",
+    "Tipo de minigr\xE1fico:",
+    "\u8FF7\u4F60\u56FE\u7C7B\u578B\uFF1A"
+  ],
+  "Line Weight:": ["\xC9paisseur du trait :", "Linienst\xE4rke:", "Grosor de l\xEDnea:", "\u7EBF\u6761\u7C97\u7EC6\uFF1A"],
+  "Changes apply to the entire selected sparkline groups.": [
+    "Les modifications s\u2019appliquent \xE0 tous les groupes de graphiques sparkline s\xE9lectionn\xE9s.",
+    "\xC4nderungen gelten f\xFCr die gesamten ausgew\xE4hlten Sparkline-Gruppen.",
+    "Los cambios se aplican a todos los grupos de minigr\xE1ficos seleccionados.",
+    "\u66F4\u6539\u5E94\u7528\u4E8E\u6574\u4E2A\u9009\u5B9A\u7684\u8FF7\u4F60\u56FE\u7EC4\u3002"
+  ],
+  "High Point": ["Point haut", "H\xF6chstpunkt", "Punto alto", "\u9AD8\u70B9"],
+  "Low Point": ["Point bas", "Tiefstpunkt", "Punto bajo", "\u4F4E\u70B9"],
+  "First Point": ["Premier point", "Erster Punkt", "Primer punto", "\u9996\u70B9"],
+  "Last Point": ["Dernier point", "Letzter Punkt", "\xDAltimo punto", "\u672B\u70B9"],
+  "Negative Points": ["Points n\xE9gatifs", "Negative Punkte", "Puntos negativos", "\u8D1F\u503C\u70B9"],
+  "Sparkline Color:": [
+    "Couleur du sparkline :",
+    "Sparkline-Farbe:",
+    "Color del minigr\xE1fico:",
+    "\u8FF7\u4F60\u56FE\u989C\u8272\uFF1A"
+  ],
+  "Negative Color:": [
+    "Couleur n\xE9gative :",
+    "Farbe f\xFCr negative Werte:",
+    "Color negativo:",
+    "\u8D1F\u503C\u989C\u8272\uFF1A"
+  ],
+  "Minimum Axis:": ["Axe minimum :", "Achsenminimum:", "Eje m\xEDnimo:", "\u6700\u5C0F\u5750\u6807\u8F74\uFF1A"],
+  "Maximum Axis:": ["Axe maximum :", "Achsenmaximum:", "Eje m\xE1ximo:", "\u6700\u5927\u5750\u6807\u8F74\uFF1A"],
+  "Minimum Value:": ["Valeur minimum :", "Mindestwert:", "Valor m\xEDnimo:", "\u6700\u5C0F\u503C\uFF1A"],
+  "Maximum Value:": ["Valeur maximum :", "H\xF6chstwert:", "Valor m\xE1ximo:", "\u6700\u5927\u503C\uFF1A"],
+  Individual: ["Individuel", "Individuell", "Individual", "\u5355\u72EC"],
+  "Same for all sparklines": [
+    "Identique pour tous les graphiques sparkline",
+    "F\xFCr alle Sparklines gleich",
+    "Igual para todos los minigr\xE1ficos",
+    "\u6240\u6709\u8FF7\u4F60\u56FE\u76F8\u540C"
+  ],
+  "Empty Cells:": ["Cellules vides :", "Leere Zellen:", "Celdas vac\xEDas:", "\u7A7A\u5355\u5143\u683C\uFF1A"],
+  "Connect data points": [
+    "Relier les points de donn\xE9es",
+    "Datenpunkte verbinden",
+    "Conectar puntos de datos",
+    "\u8FDE\u63A5\u6570\u636E\u70B9"
+  ],
+  "Show data in hidden rows and columns": [
+    "Afficher les donn\xE9es des lignes et colonnes masqu\xE9es",
+    "Daten in ausgeblendeten Zeilen und Spalten anzeigen",
+    "Mostrar datos en filas y columnas ocultas",
+    "\u663E\u793A\u9690\u85CF\u884C\u548C\u5217\u4E2D\u7684\u6570\u636E"
+  ],
+  "Show horizontal axis": [
+    "Afficher l\u2019axe horizontal",
+    "Horizontale Achse anzeigen",
+    "Mostrar eje horizontal",
+    "\u663E\u793A\u6C34\u5E73\u5750\u6807\u8F74"
+  ],
+  "Plot right to left": [
+    "Tracer de droite \xE0 gauche",
+    "Von rechts nach links zeichnen",
+    "Trazar de derecha a izquierda",
+    "\u4ECE\u53F3\u5411\u5DE6\u7ED8\u5236"
+  ],
+  "Clear Sparklines": [
+    "Effacer les graphiques sparkline",
+    "Sparklines l\xF6schen",
+    "Borrar minigr\xE1ficos",
+    "\u6E05\u9664\u8FF7\u4F60\u56FE"
+  ],
+  "Clear Selected Sparklines": [
+    "Effacer les graphiques sparkline s\xE9lectionn\xE9s",
+    "Ausgew\xE4hlte Sparklines l\xF6schen",
+    "Borrar minigr\xE1ficos seleccionados",
+    "\u6E05\u9664\u9009\u5B9A\u8FF7\u4F60\u56FE"
+  ],
+  "Clear Sparkline Groups": [
+    "Effacer les groupes de graphiques sparkline",
+    "Sparkline-Gruppen l\xF6schen",
+    "Borrar grupos de minigr\xE1ficos",
+    "\u6E05\u9664\u8FF7\u4F60\u56FE\u7EC4"
+  ],
+  "The data range and location range do not match.": [
+    "La plage de donn\xE9es et la plage d\u2019emplacement ne correspondent pas.",
+    "Datenbereich und Positionsbereich stimmen nicht \xFCberein.",
+    "El rango de datos y el rango de ubicaci\xF3n no coinciden.",
+    "\u6570\u636E\u8303\u56F4\u548C\u4F4D\u7F6E\u8303\u56F4\u4E0D\u5339\u914D\u3002"
+  ],
+  "The sparkline location range is too large.": [
+    "La plage d\u2019emplacement des graphiques sparkline est trop grande.",
+    "Der Sparkline-Positionsbereich ist zu gro\xDF.",
+    "El rango de ubicaci\xF3n del minigr\xE1fico es demasiado grande.",
+    "\u8FF7\u4F60\u56FE\u4F4D\u7F6E\u8303\u56F4\u8FC7\u5927\u3002"
+  ],
+  "The location range already contains sparklines.": [
+    "La plage d\u2019emplacement contient d\xE9j\xE0 des graphiques sparkline.",
+    "Der Positionsbereich enth\xE4lt bereits Sparklines.",
+    "El rango de ubicaci\xF3n ya contiene minigr\xE1ficos.",
+    "\u4F4D\u7F6E\u8303\u56F4\u5DF2\u5305\u542B\u8FF7\u4F60\u56FE\u3002"
+  ],
+  "Sparklines cannot be created in merged cells.": [
+    "Impossible de cr\xE9er des graphiques sparkline dans des cellules fusionn\xE9es.",
+    "Sparklines k\xF6nnen nicht in verbundenen Zellen erstellt werden.",
+    "No se pueden crear minigr\xE1ficos en celdas combinadas.",
+    "\u65E0\u6CD5\u5728\u5408\u5E76\u5355\u5143\u683C\u4E2D\u521B\u5EFA\u8FF7\u4F60\u56FE\u3002"
+  ],
+  "The sparkline settings are not valid.": [
+    "Les param\xE8tres des graphiques sparkline ne sont pas valides.",
+    "Die Sparkline-Einstellungen sind ung\xFCltig.",
+    "La configuraci\xF3n del minigr\xE1fico no es v\xE1lida.",
+    "\u8FF7\u4F60\u56FE\u8BBE\u7F6E\u65E0\u6548\u3002"
+  ],
+  "The sparkline axis limits are not valid.": [
+    "Les limites d\u2019axe des graphiques sparkline ne sont pas valides.",
+    "Die Sparkline-Achsengrenzen sind ung\xFCltig.",
+    "Los l\xEDmites del eje del minigr\xE1fico no son v\xE1lidos.",
+    "\u8FF7\u4F60\u56FE\u5750\u6807\u8F74\u754C\u9650\u65E0\u6548\u3002"
+  ]
+};
+
+// xlsx/ui/commands/i18n/pivots.ts
+var PIVOT_STRINGS = {
+  "Compact Form": ["Forme compacte", "Kompaktformat", "Formato compacto", "\u538B\u7F29\u5F62\u5F0F"],
+  "Outline Form": ["Forme de plan", "Gliederungsformat", "Formato de esquema", "\u5927\u7EB2\u5F62\u5F0F"],
+  "Tabular Form": ["Forme tabulaire", "Tabellenformat", "Formato tabular", "\u8868\u683C\u5F62\u5F0F"],
+  "Report Layout:": [
+    "Disposition du rapport :",
+    "Berichtslayout:",
+    "Dise\xF1o del informe:",
+    "\u62A5\u8868\u5E03\u5C40\uFF1A"
+  ],
+  "Subtotal Position:": [
+    "Position des sous-totaux :",
+    "Position der Teilergebnisse:",
+    "Posici\xF3n de subtotales:",
+    "\u5206\u7C7B\u6C47\u603B\u4F4D\u7F6E\uFF1A"
+  ],
+  "Above each group": [
+    "Au-dessus de chaque groupe",
+    "\xDCber jeder Gruppe",
+    "Encima de cada grupo",
+    "\u6BCF\u7EC4\u4E0A\u65B9"
+  ],
+  "Below each group": [
+    "Sous chaque groupe",
+    "Unter jeder Gruppe",
+    "Debajo de cada grupo",
+    "\u6BCF\u7EC4\u4E0B\u65B9"
+  ],
+  "Show subtotals": [
+    "Afficher les sous-totaux",
+    "Teilergebnisse anzeigen",
+    "Mostrar subtotales",
+    "\u663E\u793A\u5206\u7C7B\u6C47\u603B"
+  ],
+  "Tabular layout displays subtotals below groups.": [
+    "La disposition tabulaire affiche les sous-totaux sous les groupes.",
+    "Das tabellarische Layout zeigt Teilergebnisse unter den Gruppen.",
+    "El dise\xF1o tabular muestra subtotales debajo de los grupos.",
+    "\u8868\u683C\u5E03\u5C40\u5728\u7EC4\u4E0B\u65B9\u663E\u793A\u5206\u7C7B\u6C47\u603B\u3002"
+  ],
+  "Second Row Field:": [
+    "Deuxi\xE8me champ de ligne :",
+    "Zweites Zeilenfeld:",
+    "Segundo campo de fila:",
+    "\u7B2C\u4E8C\u884C\u5B57\u6BB5\uFF1A"
+  ],
+  "Show subtotals below each group": [
+    "Afficher les sous-totaux sous chaque groupe",
+    "Teilergebnisse unter jeder Gruppe anzeigen",
+    "Mostrar subtotales debajo de cada grupo",
+    "\u5728\u6BCF\u7EC4\u4E0B\u65B9\u663E\u793A\u5206\u7C7B\u6C47\u603B"
+  ],
+  "Repeat row labels": [
+    "R\xE9p\xE9ter les \xE9tiquettes de ligne",
+    "Zeilenbeschriftungen wiederholen",
+    "Repetir etiquetas de fila",
+    "\u91CD\u590D\u884C\u6807\u7B7E"
+  ],
+  "Charts, sparklines and worksheet-range PivotTables support editing. Advanced PivotTables, macros and other unsupported parts are preserved.": [
+    "Les graphiques, graphiques sparkline et tableaux crois\xE9s dynamiques de plages prennent en charge la modification. Les tableaux avanc\xE9s, macros et autres \xE9l\xE9ments non pris en charge sont conserv\xE9s.",
+    "Diagramme, Sparklines und PivotTables aus Arbeitsblattbereichen k\xF6nnen bearbeitet werden. Erweiterte PivotTables, Makros und andere nicht unterst\xFCtzte Teile bleiben erhalten.",
+    "Los gr\xE1ficos, minigr\xE1ficos y tablas din\xE1micas de rangos admiten edici\xF3n. Se conservan las tablas avanzadas, macros y otros elementos no compatibles.",
+    "\u652F\u6301\u7F16\u8F91\u56FE\u8868\u3001\u8FF7\u4F60\u56FE\u548C\u5DE5\u4F5C\u8868\u533A\u57DF\u6570\u636E\u900F\u89C6\u8868\u3002\u4FDD\u7559\u9AD8\u7EA7\u6570\u636E\u900F\u89C6\u8868\u3001\u5B8F\u548C\u5176\u4ED6\u4E0D\u652F\u6301\u7684\u5185\u5BB9\u3002"
+  ],
+  PivotTable: ["Tableau crois\xE9 dynamique", "PivotTable", "Tabla din\xE1mica", "\u6570\u636E\u900F\u89C6\u8868"],
+  "Create PivotTable": [
+    "Cr\xE9er un tableau crois\xE9 dynamique",
+    "PivotTable erstellen",
+    "Crear tabla din\xE1mica",
+    "\u521B\u5EFA\u6570\u636E\u900F\u89C6\u8868"
+  ],
+  "PivotTable Settings": [
+    "Param\xE8tres du tableau crois\xE9 dynamique",
+    "PivotTable-Einstellungen",
+    "Configuraci\xF3n de tabla din\xE1mica",
+    "\u6570\u636E\u900F\u89C6\u8868\u8BBE\u7F6E"
+  ],
+  "Refresh PivotTable": [
+    "Actualiser le tableau crois\xE9 dynamique",
+    "PivotTable aktualisieren",
+    "Actualizar tabla din\xE1mica",
+    "\u5237\u65B0\u6570\u636E\u900F\u89C6\u8868"
+  ],
+  "Delete PivotTable": [
+    "Supprimer le tableau crois\xE9 dynamique",
+    "PivotTable l\xF6schen",
+    "Eliminar tabla din\xE1mica",
+    "\u5220\u9664\u6570\u636E\u900F\u89C6\u8868"
+  ],
+  "Source Range:": ["Plage source :", "Quellbereich:", "Rango de origen:", "\u6E90\u533A\u57DF\uFF1A"],
+  "Destination Cell:": [
+    "Cellule de destination :",
+    "Zielzelle:",
+    "Celda de destino:",
+    "\u76EE\u6807\u5355\u5143\u683C\uFF1A"
+  ],
+  "Row Field:": ["Champ de ligne :", "Zeilenfeld:", "Campo de fila:", "\u884C\u5B57\u6BB5\uFF1A"],
+  "Column Field:": ["Champ de colonne :", "Spaltenfeld:", "Campo de columna:", "\u5217\u5B57\u6BB5\uFF1A"],
+  "Value Field:": ["Champ de valeur :", "Wertfeld:", "Campo de valor:", "\u503C\u5B57\u6BB5\uFF1A"],
+  "Summarize Values By:": [
+    "Synth\xE9tiser les valeurs par :",
+    "Werte zusammenfassen nach:",
+    "Resumir valores por:",
+    "\u503C\u6C47\u603B\u65B9\u5F0F\uFF1A"
+  ],
+  "(None)": ["(Aucun)", "(Keine)", "(Ninguno)", "\uFF08\u65E0\uFF09"]
+};
+
+// xlsx/ui/commands/i18n/print-layout.ts
+var PRINT_LAYOUT_STRINGS = {
+  "Unsupported header/footer codes are preserved but not rendered.": [
+    "Les codes d\u2019en-t\xEAte et pied non pris en charge sont conserv\xE9s mais non rendus.",
+    "Nicht unterst\xFCtzte Kopf- und Fu\xDFzeilencodes bleiben erhalten, werden aber nicht dargestellt.",
+    "Se conservan los c\xF3digos no compatibles del encabezado y pie, pero no se muestran.",
+    "\u4FDD\u7559\u4E0D\u652F\u6301\u7684\u9875\u7709\u548C\u9875\u811A\u4EE3\u7801\uFF0C\u4F46\u4E0D\u663E\u793A\u3002"
+  ],
+  "Browser printing includes page setup, manual breaks, leading print titles and header/footer fields. Drawings and unsupported formatting are preserved but not rendered.": [
+    "L\u2019impression du navigateur inclut la mise en page, les sauts manuels, les titres en t\xEAte et les champs d\u2019en-t\xEAte et pied. Les dessins et formats non pris en charge sont conserv\xE9s mais non rendus.",
+    "Der Browserdruck umfasst Seiteneinrichtung, manuelle Umbr\xFCche, f\xFChrende Drucktitel sowie Kopf- und Fu\xDFzeilenfelder. Zeichnungen und nicht unterst\xFCtzte Formatierung bleiben erhalten, werden aber nicht dargestellt.",
+    "La impresi\xF3n del navegador incluye configuraci\xF3n de p\xE1gina, saltos manuales, t\xEDtulos iniciales y campos de encabezado y pie. Se conservan dibujos y formatos no compatibles, pero no se muestran.",
+    "\u6D4F\u89C8\u5668\u6253\u5370\u5305\u542B\u9875\u9762\u8BBE\u7F6E\u3001\u624B\u52A8\u5206\u9875\u7B26\u3001\u8D77\u59CB\u6253\u5370\u6807\u9898\u548C\u9875\u7709\u9875\u811A\u5B57\u6BB5\u3002\u4FDD\u7559\u7ED8\u56FE\u548C\u4E0D\u652F\u6301\u7684\u683C\u5F0F\uFF0C\u4F46\u4E0D\u663E\u793A\u3002"
+  ],
+  "Non-leading or unsupported print titles are preserved but not rendered.": [
+    "Les titres non plac\xE9s en t\xEAte ou non pris en charge sont conserv\xE9s mais non rendus.",
+    "Nicht f\xFChrende oder nicht unterst\xFCtzte Drucktitel bleiben erhalten, werden aber nicht dargestellt.",
+    "Se conservan los t\xEDtulos no iniciales o no compatibles, pero no se muestran.",
+    "\u4FDD\u7559\u975E\u8D77\u59CB\u6216\u4E0D\u652F\u6301\u7684\u6253\u5370\u6807\u9898\uFF0C\u4F46\u4E0D\u663E\u793A\u3002"
+  ],
+  "Print title ranges are too large for preview.": [
+    "Les plages de titres sont trop grandes pour l\u2019aper\xE7u.",
+    "Die Drucktitelbereiche sind f\xFCr die Vorschau zu gro\xDF.",
+    "Los rangos de t\xEDtulos son demasiado grandes para la vista previa.",
+    "\u6253\u5370\u6807\u9898\u533A\u57DF\u8FC7\u5927\uFF0C\u65E0\u6CD5\u9884\u89C8\u3002"
+  ],
+  "Repeated titles leave no room for worksheet data.": [
+    "Les titres r\xE9p\xE9t\xE9s ne laissent pas de place aux donn\xE9es.",
+    "Wiederholte Titel lassen keinen Platz f\xFCr Arbeitsblattdaten.",
+    "Los t\xEDtulos repetidos no dejan espacio para los datos.",
+    "\u91CD\u590D\u6807\u9898\u672A\u7ED9\u5DE5\u4F5C\u8868\u6570\u636E\u7559\u51FA\u7A7A\u95F4\u3002"
+  ],
+  "Preview does not render drawings.": [
+    "L\u2019aper\xE7u ne rend pas les dessins.",
+    "Die Vorschau stellt Zeichnungen nicht dar.",
+    "La vista previa no muestra dibujos.",
+    "\u9884\u89C8\u4E0D\u663E\u793A\u7ED8\u56FE\u3002"
+  ],
+  "Unsupported header or footer formatting and image fields are preserved but not rendered.": [
+    "Les formats et champs d\u2019image non pris en charge des en-t\xEAtes et pieds sont conserv\xE9s mais non rendus.",
+    "Nicht unterst\xFCtzte Formatierungen und Bildfelder in Kopf- und Fu\xDFzeilen bleiben erhalten, werden aber nicht dargestellt.",
+    "Se conservan los formatos y campos de imagen no compatibles del encabezado y pie, pero no se muestran.",
+    "\u4FDD\u7559\u4E0D\u652F\u6301\u7684\u9875\u7709\u548C\u9875\u811A\u683C\u5F0F\u53CA\u56FE\u50CF\u5B57\u6BB5\uFF0C\u4F46\u4E0D\u663E\u793A\u3002"
+  ],
+  "Merged print ranges are too large.": [
+    "Les plages fusionn\xE9es \xE0 imprimer sont trop grandes.",
+    "Die verbundenen Druckbereiche sind zu gro\xDF.",
+    "Los rangos combinados de impresi\xF3n son demasiado grandes.",
+    "\u5408\u5E76\u6253\u5370\u533A\u57DF\u8FC7\u5927\u3002"
+  ],
+  "Multiple or unsupported print areas are preserved; preview uses the worksheet used range.": [
+    "Les zones d\u2019impression multiples ou non prises en charge sont conserv\xE9es ; l\u2019aper\xE7u utilise la plage utilis\xE9e de la feuille.",
+    "Mehrere oder nicht unterst\xFCtzte Druckbereiche bleiben erhalten; die Vorschau verwendet den benutzten Arbeitsblattbereich.",
+    "Se conservan las \xE1reas m\xFAltiples o no compatibles; la vista previa usa el rango utilizado de la hoja.",
+    "\u4FDD\u7559\u591A\u4E2A\u6216\u4E0D\u652F\u6301\u7684\u6253\u5370\u533A\u57DF\uFF1B\u9884\u89C8\u4F7F\u7528\u5DE5\u4F5C\u8868\u5DF2\u7528\u533A\u57DF\u3002"
+  ],
+  "Previous Page": ["Page pr\xE9c\xE9dente", "Vorherige Seite", "P\xE1gina anterior", "\u4E0A\u4E00\u9875"],
+  "Next Page": ["Page suivante", "N\xE4chste Seite", "P\xE1gina siguiente", "\u4E0B\u4E00\u9875"],
+  "Actual Size": ["Taille r\xE9elle", "Tats\xE4chliche Gr\xF6\xDFe", "Tama\xF1o real", "\u5B9E\u9645\u5927\u5C0F"],
+  "Fit Page": ["Ajuster \xE0 la page", "Seite einpassen", "Ajustar p\xE1gina", "\u9002\u5408\u9875\u9762"],
+  "Page {page} of {count}": [
+    "Page {page} sur {count}",
+    "Seite {page} von {count}",
+    "P\xE1gina {page} de {count}",
+    "\u7B2C {page} \u9875\uFF0C\u5171 {count} \u9875"
+  ],
+  "Repeated print titles are preserved but not rendered in preview.": [
+    "Les titres d\u2019impression r\xE9p\xE9t\xE9s sont conserv\xE9s mais non rendus dans l\u2019aper\xE7u.",
+    "Wiederholte Drucktitel bleiben erhalten, werden aber in der Vorschau nicht dargestellt.",
+    "Se conservan los t\xEDtulos repetidos, pero no se muestran en la vista previa.",
+    "\u4FDD\u7559\u91CD\u590D\u6253\u5370\u6807\u9898\uFF0C\u4F46\u4E0D\u5728\u9884\u89C8\u4E2D\u663E\u793A\u3002"
+  ],
+  "Merged cells crossing pages are rendered separately on each page.": [
+    "Les cellules fusionn\xE9es sur plusieurs pages sont rendues s\xE9par\xE9ment sur chaque page.",
+    "Seiten\xFCbergreifende verbundene Zellen werden auf jeder Seite getrennt dargestellt.",
+    "Las celdas combinadas entre p\xE1ginas se muestran por separado en cada p\xE1gina.",
+    "\u8DE8\u9875\u5408\u5E76\u5355\u5143\u683C\u5C06\u5728\u6BCF\u9875\u5206\u522B\u663E\u793A\u3002"
+  ],
+  "Browser printing uses paper size, margins, scaling and manual page breaks. Drawings, headers, footers and repeated titles are not rendered.": [
+    "L\u2019impression du navigateur utilise le format du papier, les marges, l\u2019\xE9chelle et les sauts manuels. Les dessins, en-t\xEAtes, pieds de page et titres r\xE9p\xE9t\xE9s ne sont pas rendus.",
+    "Der Browserdruck verwendet Papierformat, R\xE4nder, Skalierung und manuelle Seitenumbr\xFCche. Zeichnungen, Kopf- und Fu\xDFzeilen sowie wiederholte Titel werden nicht dargestellt.",
+    "La impresi\xF3n del navegador usa tama\xF1o de papel, m\xE1rgenes, escala y saltos manuales. No muestra dibujos, encabezados, pies ni t\xEDtulos repetidos.",
+    "\u6D4F\u89C8\u5668\u6253\u5370\u4F7F\u7528\u7EB8\u5F20\u5C3A\u5BF8\u3001\u8FB9\u8DDD\u3001\u7F29\u653E\u548C\u624B\u52A8\u5206\u9875\u7B26\u3002\u4E0D\u663E\u793A\u7ED8\u56FE\u3001\u9875\u7709\u3001\u9875\u811A\u6216\u91CD\u590D\u6807\u9898\u3002"
+  ],
+  "Print Preview": [
+    "Aper\xE7u avant impression",
+    "Druckvorschau",
+    "Vista previa de impresi\xF3n",
+    "\u6253\u5370\u9884\u89C8"
+  ],
+  Breaks: ["Sauts", "Umbr\xFCche", "Saltos", "\u5206\u9875\u7B26"],
+  "Insert Row Page Break": [
+    "Ins\xE9rer un saut de page de ligne",
+    "Zeilen-Seitenumbruch einf\xFCgen",
+    "Insertar salto de p\xE1gina de fila",
+    "\u63D2\u5165\u884C\u5206\u9875\u7B26"
+  ],
+  "Insert Column Page Break": [
+    "Ins\xE9rer un saut de page de colonne",
+    "Spalten-Seitenumbruch einf\xFCgen",
+    "Insertar salto de p\xE1gina de columna",
+    "\u63D2\u5165\u5217\u5206\u9875\u7B26"
+  ],
+  "Remove Row Page Break": [
+    "Supprimer le saut de page de ligne",
+    "Zeilen-Seitenumbruch entfernen",
+    "Quitar salto de p\xE1gina de fila",
+    "\u5220\u9664\u884C\u5206\u9875\u7B26"
+  ],
+  "Remove Column Page Break": [
+    "Supprimer le saut de page de colonne",
+    "Spalten-Seitenumbruch entfernen",
+    "Quitar salto de p\xE1gina de columna",
+    "\u5220\u9664\u5217\u5206\u9875\u7B26"
+  ],
+  "Reset All Page Breaks": [
+    "R\xE9initialiser tous les sauts de page",
+    "Alle Seitenumbr\xFCche zur\xFCcksetzen",
+    "Restablecer todos los saltos de p\xE1gina",
+    "\u91CD\u7F6E\u6240\u6709\u5206\u9875\u7B26"
+  ],
+  "Pages: {count} | Scale: {scale}%": [
+    "Pages : {count} | \xC9chelle : {scale}%",
+    "Seiten: {count} | Skalierung: {scale}%",
+    "P\xE1ginas: {count} | Escala: {scale}%",
+    "\u9875\u6570\uFF1A{count} | \u7F29\u653E\uFF1A{scale}%"
+  ],
+  "Preview uses worksheet dimensions. Fonts and printer margins may change pagination in Excel.": [
+    "L\u2019aper\xE7u utilise les dimensions de la feuille. Les polices et marges de l\u2019imprimante peuvent modifier la pagination dans Excel.",
+    "Die Vorschau verwendet die Arbeitsblattma\xDFe. Schriftarten und Druckerr\xE4nder k\xF6nnen die Seitenaufteilung in Excel \xE4ndern.",
+    "La vista previa usa las dimensiones de la hoja. Las fuentes y los m\xE1rgenes de impresora pueden cambiar la paginaci\xF3n en Excel.",
+    "\u9884\u89C8\u4F7F\u7528\u5DE5\u4F5C\u8868\u5C3A\u5BF8\u3002\u5B57\u4F53\u548C\u6253\u5370\u673A\u8FB9\u8DDD\u53EF\u80FD\u6539\u53D8 Excel \u4E2D\u7684\u5206\u9875\u3002"
+  ],
+  "Fit to pages ignores manual page breaks.": [
+    "L\u2019ajustement aux pages ignore les sauts manuels.",
+    "Beim Anpassen an Seiten werden manuelle Umbr\xFCche ignoriert.",
+    "Ajustar a p\xE1ginas ignora los saltos manuales.",
+    "\u8C03\u6574\u4E3A\u6307\u5B9A\u9875\u6570\u65F6\u5FFD\u7565\u624B\u52A8\u5206\u9875\u7B26\u3002"
+  ],
+  "Preview does not render drawings, headers or footers.": [
+    "L\u2019aper\xE7u ne rend pas les dessins, en-t\xEAtes ou pieds de page.",
+    "Die Vorschau stellt Zeichnungen, Kopf- und Fu\xDFzeilen nicht dar.",
+    "La vista previa no muestra dibujos, encabezados ni pies de p\xE1gina.",
+    "\u9884\u89C8\u4E0D\u663E\u793A\u7ED8\u56FE\u3001\u9875\u7709\u6216\u9875\u811A\u3002"
+  ],
+  "Partial page breaks are preserved but not used in preview.": [
+    "Les sauts de page partiels sont conserv\xE9s mais non utilis\xE9s dans l\u2019aper\xE7u.",
+    "Teilweise Seitenumbr\xFCche bleiben erhalten, werden aber in der Vorschau nicht verwendet.",
+    "Se conservan los saltos parciales, pero no se usan en la vista previa.",
+    "\u4FDD\u7559\u5C40\u90E8\u5206\u9875\u7B26\uFF0C\u4F46\u4E0D\u5728\u9884\u89C8\u4E2D\u4F7F\u7528\u3002"
+  ],
+  "This paper size is not supported in preview; Letter is used.": [
+    "Ce format n\u2019est pas pris en charge dans l\u2019aper\xE7u ; Letter est utilis\xE9.",
+    "Dieses Papierformat wird in der Vorschau nicht unterst\xFCtzt; Letter wird verwendet.",
+    "Este tama\xF1o no se admite en la vista previa; se usa Carta.",
+    "\u9884\u89C8\u4E0D\u652F\u6301\u6B64\u7EB8\u5F20\u5C3A\u5BF8\uFF0C\u4F7F\u7528 Letter\u3002"
+  ],
+  "The minimum scale prevents fitting the requested number of pages.": [
+    "L\u2019\xE9chelle minimale emp\xEAche l\u2019ajustement au nombre de pages demand\xE9.",
+    "Die minimale Skalierung verhindert die gew\xFCnschte Seitenanzahl.",
+    "La escala m\xEDnima impide ajustar al n\xFAmero de p\xE1ginas solicitado.",
+    "\u6700\u5C0F\u7F29\u653E\u6BD4\u4F8B\u65E0\u6CD5\u6EE1\u8DB3\u6307\u5B9A\u9875\u6570\u3002"
+  ],
+  "Rows or columns larger than a printed page are clipped.": [
+    "Les lignes ou colonnes plus grandes qu\u2019une page sont rogn\xE9es.",
+    "Zeilen oder Spalten, die gr\xF6\xDFer als eine Druckseite sind, werden abgeschnitten.",
+    "Las filas o columnas mayores que una p\xE1gina se recortan.",
+    "\u8D85\u8FC7\u6253\u5370\u9875\u9762\u5927\u5C0F\u7684\u884C\u6216\u5217\u5C06\u88AB\u88C1\u526A\u3002"
+  ],
+  "Margins do not fit the paper size.": [
+    "Les marges ne correspondent pas au format du papier.",
+    "Die R\xE4nder passen nicht zum Papierformat.",
+    "Los m\xE1rgenes no caben en el tama\xF1o de papel.",
+    "\u8FB9\u8DDD\u8D85\u51FA\u7EB8\u5F20\u5C3A\u5BF8\u3002"
+  ],
+  "Print preview supports at most one million cells.": [
+    "L\u2019aper\xE7u prend en charge au maximum un million de cellules.",
+    "Die Druckvorschau unterst\xFCtzt h\xF6chstens eine Million Zellen.",
+    "La vista previa admite como m\xE1ximo un mill\xF3n de celdas.",
+    "\u6253\u5370\u9884\u89C8\u6700\u591A\u652F\u6301\u4E00\u767E\u4E07\u4E2A\u5355\u5143\u683C\u3002"
+  ],
+  "Print preview supports at most 1000 pages.": [
+    "L\u2019aper\xE7u prend en charge au maximum 1000 pages.",
+    "Die Druckvorschau unterst\xFCtzt h\xF6chstens 1000 Seiten.",
+    "La vista previa admite como m\xE1ximo 1000 p\xE1ginas.",
+    "\u6253\u5370\u9884\u89C8\u6700\u591A\u652F\u6301 1000 \u9875\u3002"
+  ],
+  "Choose a row or column after the first to set a page break.": [
+    "Choisissez une ligne ou colonne apr\xE8s la premi\xE8re pour d\xE9finir un saut de page.",
+    "W\xE4hlen Sie eine Zeile oder Spalte nach der ersten f\xFCr einen Seitenumbruch.",
+    "Elija una fila o columna despu\xE9s de la primera para establecer un salto.",
+    "\u8BF7\u9009\u62E9\u7B2C\u4E00\u884C\u6216\u7B2C\u4E00\u5217\u4E4B\u540E\u7684\u4F4D\u7F6E\u8BBE\u7F6E\u5206\u9875\u7B26\u3002"
+  ],
+  "A worksheet can have at most 1026 manual breaks on each axis.": [
+    "Une feuille peut contenir au maximum 1026 sauts manuels par axe.",
+    "Ein Arbeitsblatt kann h\xF6chstens 1026 manuelle Umbr\xFCche pro Achse enthalten.",
+    "Una hoja admite como m\xE1ximo 1026 saltos manuales por eje.",
+    "\u5DE5\u4F5C\u8868\u6BCF\u4E2A\u65B9\u5411\u6700\u591A\u652F\u6301 1026 \u4E2A\u624B\u52A8\u5206\u9875\u7B26\u3002"
+  ]
+};
+
 // xlsx/ui/commands/i18n/types.ts
 var COLUMN = {
   fr: 0,
@@ -27104,7 +28777,10 @@ var COMMAND_TABLES = [
   FORMAT_CELLS_STRINGS,
   RULES_STRINGS,
   CORE_FEATURE_STRINGS,
-  CHART_SERIES_STRINGS
+  CHART_SERIES_STRINGS,
+  SPARKLINE_STRINGS,
+  PIVOT_STRINGS,
+  PRINT_LAYOUT_STRINGS
 ];
 var commandStrings = (locale) => flatten2(COMMAND_TABLES, locale);
 
@@ -29281,9 +30957,9 @@ function cellCommands() {
       ["format.hide-columns", "Hide Columns", "col", true],
       ["format.unhide-columns", "Unhide Columns", "col", false]
     ].map(
-      ([id, label2, axis, hidden]) => editing({
+      ([id, label3, axis, hidden]) => editing({
         id,
-        label: label2,
+        label: label3,
         icon: icon("hide"),
         lock: axis === "row" ? "formatRows" : "formatColumns",
         run: (ctx) => {
@@ -29322,47 +30998,47 @@ function cellCommands() {
 }
 
 // xlsx/ui/commands/cf-presets.ts
-var argb = (hex2) => ({ rgb: `FF${hex2}` });
+var argb2 = (hex2) => ({ rgb: `FF${hex2}` });
 var HIGHLIGHT_STYLES = [
   [
     "lightRed",
     "Light Red Fill with Dark Red Text",
     {
-      font: { color: argb("9C0006") },
-      fill: { type: "pattern", pattern: "solid", bgColor: argb("FFC7CE") }
+      font: { color: argb2("9C0006") },
+      fill: { type: "pattern", pattern: "solid", bgColor: argb2("FFC7CE") }
     }
   ],
   [
     "yellow",
     "Yellow Fill with Dark Yellow Text",
     {
-      font: { color: argb("9C5700") },
-      fill: { type: "pattern", pattern: "solid", bgColor: argb("FFEB9C") }
+      font: { color: argb2("9C5700") },
+      fill: { type: "pattern", pattern: "solid", bgColor: argb2("FFEB9C") }
     }
   ],
   [
     "green",
     "Green Fill with Dark Green Text",
     {
-      font: { color: argb("006100") },
-      fill: { type: "pattern", pattern: "solid", bgColor: argb("C6EFCE") }
+      font: { color: argb2("006100") },
+      fill: { type: "pattern", pattern: "solid", bgColor: argb2("C6EFCE") }
     }
   ],
   [
     "lightRedFill",
     "Light Red Fill",
-    { fill: { type: "pattern", pattern: "solid", bgColor: argb("FFC7CE") } }
+    { fill: { type: "pattern", pattern: "solid", bgColor: argb2("FFC7CE") } }
   ],
-  ["redText", "Red Text", { font: { color: argb("9C0006") } }],
+  ["redText", "Red Text", { font: { color: argb2("9C0006") } }],
   [
     "redBorder",
     "Red Border",
     {
       border: {
-        left: { style: "thin", color: argb("9C0006") },
-        right: { style: "thin", color: argb("9C0006") },
-        top: { style: "thin", color: argb("9C0006") },
-        bottom: { style: "thin", color: argb("9C0006") }
+        left: { style: "thin", color: argb2("9C0006") },
+        right: { style: "thin", color: argb2("9C0006") },
+        top: { style: "thin", color: argb2("9C0006") },
+        bottom: { style: "thin", color: argb2("9C0006") }
       }
     }
   ]
@@ -29419,13 +31095,13 @@ function dataBarRule(hex2) {
     type: "dataBar",
     min: { type: "min" },
     max: { type: "max" },
-    color: argb(hex2),
+    color: argb2(hex2),
     priority: 1
   };
 }
 function colorScaleRule(colors) {
   const thresholds = colors.length === 3 ? [{ type: "min" }, { type: "percentile", value: "50" }, { type: "max" }] : [{ type: "min" }, { type: "max" }];
-  return { type: "colorScale", thresholds, colors: colors.map(argb), priority: 1 };
+  return { type: "colorScale", thresholds, colors: colors.map(argb2), priority: 1 };
 }
 function iconSetRule(set) {
   return { type: "iconSet", iconSet: set, thresholds: iconThresholds(iconCount(set)), priority: 1 };
@@ -29595,10 +31271,10 @@ function activeChart(ctx) {
   const picked = t.ws.drawings[index2];
   return picked?.kind === "chart" ? { chart: picked, index: index2 } : void 0;
 }
-function editChart(ctx, patch) {
+function editChart(ctx, patch2) {
   const t = target(ctx);
   const found = activeChart(ctx);
-  if (t && found) t.session.updateChart(t.sheet, found.index, patch(found.chart));
+  if (t && found) t.session.updateChart(t.sheet, found.index, patch2(found.chart));
 }
 var TABLE_FLAGS = [
   ["showRowStripes", "table.banded-rows", "Banded Rows"],
@@ -29637,8 +31313,8 @@ function contextualCommands() {
         const t = target(ctx);
         const found = activeChart(ctx);
         if (!t || !found) return;
-        const patch = chartColorPalettePatch(found.chart, id);
-        if (patch) t.session.updateChart(t.sheet, found.index, patch);
+        const patch2 = chartColorPalettePatch(found.chart, id);
+        if (patch2) t.session.updateChart(t.sheet, found.index, patch2);
       }
     }),
     tableCmd({
@@ -29684,9 +31360,9 @@ function contextualCommands() {
       run: (ctx) => setTableBand(ctx, "totalsRow", !activeTable(ctx)?.totalsRow)
     }),
     ...TABLE_FLAGS.map(
-      ([flag2, id, label2]) => tableCmd({
+      ([flag2, id, label3]) => tableCmd({
         id,
-        label: label2,
+        label: label3,
         checked: (ctx) => !!activeTable(ctx)?.[flag2],
         run: (ctx) => {
           const t = target(ctx);
@@ -30069,9 +31745,9 @@ function fillDirection(ctx, dir) {
 function editingCommands() {
   return [
     ...AUTOSUM_FUNCTIONS.map(
-      ([fn, label2]) => editing({
+      ([fn, label3]) => editing({
         id: fn === "SUM" ? "home.autosum" : `home.autosum-${fn.toLowerCase()}`,
-        label: fn === "SUM" ? "AutoSum" : label2,
+        label: fn === "SUM" ? "AutoSum" : label3,
         icon: icon("autoSum"),
         ...fn === "SUM" ? { shortcut: "Alt+=" } : {},
         run: (ctx) => autoSum(ctx, fn)
@@ -30122,16 +31798,16 @@ function editingCommands() {
       ["comments", "Clear Comments and Notes"],
       ["hyperlinks", "Clear Hyperlinks"]
     ].map(
-      ([what, label2]) => editing({
+      ([what, label3]) => editing({
         id: `home.clear-${what}`,
-        label: label2,
+        label: label3,
         icon: icon("clear"),
         ...what === "formats" ? { lock: "formatCells" } : {},
         ...what === "contents" ? { shortcut: "Delete" } : {},
         run: (ctx) => {
           const t = target(ctx);
           if (!t) return;
-          t.session.batch(label2, () => {
+          t.session.batch(label3, () => {
             for (const range2 of t.ranges) t.session.clearRange(t.sheet, range2, what);
           });
         }
@@ -30172,9 +31848,9 @@ function editingCommands() {
       ["constants", "Constants"],
       ["validation", "Data Validation"]
     ].map(
-      ([kind, label2]) => viewing({
+      ([kind, label3]) => viewing({
         id: `home.select-${kind}`,
-        label: label2,
+        label: label3,
         icon: icon("findSelect"),
         run: (ctx) => {
           if (!selectSpecial(ctx, { kind })) ctx.toast(ctx.t("No cells were found."), "info");
@@ -30445,7 +32121,7 @@ function numberCommands() {
       ["home.format-date", "Date format", "d-mmm-yy", "Ctrl+Shift+#"],
       ["home.format-scientific", "Scientific format", "0.00E+00", "Ctrl+Shift+^"]
     ].map(
-      ([id, label2, format, shortcut]) => editing({ id, label: label2, shortcut, lock: "formatCells", run: (ctx) => setFormat(ctx, format) })
+      ([id, label3, format, shortcut]) => editing({ id, label: label3, shortcut, lock: "formatCells", run: (ctx) => setFormat(ctx, format) })
     )
   ];
 }
@@ -30476,9 +32152,9 @@ var PAPER_SIZES = [
   [27, "Envelope DL"]
 ];
 var page = (ctx) => target(ctx)?.ws.pageSetup ?? {};
-var setPage = (ctx, patch) => {
+var setPage = (ctx, patch2) => {
   const t = target(ctx);
-  if (t) t.session.setPageSetup(t.sheet, patch);
+  if (t) t.session.setPageSetup(t.sheet, patch2);
 };
 function pageLayoutCommands() {
   return [
@@ -30611,6 +32287,43 @@ function pageLayoutCommands() {
   ];
 }
 
+// xlsx/ui/commands/page-breaks.ts
+function pageBreakCommands() {
+  return [
+    viewing({
+      id: "page.preview",
+      label: "Print Preview",
+      icon: icon("pageSetup"),
+      run: (ctx) => void ctx.dialogs.open("print-preview")
+    }),
+    ...["row", "col"].flatMap(
+      (axis) => [true, false].map(
+        (present) => editing({
+          id: `page.break-${axis}-${present ? "insert" : "remove"}`,
+          label: present ? axis === "row" ? "Insert Row Page Break" : "Insert Column Page Break" : axis === "row" ? "Remove Row Page Break" : "Remove Column Page Break",
+          icon: icon("printArea"),
+          lock: false,
+          enabled: (ctx) => (target(ctx)?.active[axis] ?? 0) > 0,
+          run: (ctx) => {
+            const t = target(ctx);
+            if (t) t.session.setPageBreak(t.sheet, axis, t.active[axis], present);
+          }
+        })
+      )
+    ),
+    editing({
+      id: "page.breaks-reset",
+      label: "Reset All Page Breaks",
+      icon: icon("printArea"),
+      lock: false,
+      run: (ctx) => {
+        const t = target(ctx);
+        if (t) t.session.resetPageBreaks(t.sheet);
+      }
+    })
+  ];
+}
+
 // xlsx/ui/commands/style-presets.ts
 var TABLE_STYLES = [
   ...Array.from({ length: 21 }, (_v, i2) => ({
@@ -30634,9 +32347,9 @@ function tableStyleColor(info, theme2) {
   if (slot === 0) return info.family === "Dark" ? "404040" : "808080";
   return theme2.colors[3 + slot] ?? "4472C4";
 }
-var escapeAttr = (s) => s.replace(/[^0-9A-Fa-f]/g, "");
+var escapeAttr2 = (s) => s.replace(/[^0-9A-Fa-f]/g, "");
 function tableStylePreview(info, theme2) {
-  const c = `#${escapeAttr(tableStyleColor(info, theme2))}`;
+  const c = `#${escapeAttr2(tableStyleColor(info, theme2))}`;
   const dark = info.family === "Dark";
   const header = info.family === "Light" ? "#ffffff" : c;
   const band = dark ? c : info.family === "Medium" ? `${c}55` : `${c}33`;
@@ -32309,13 +34022,13 @@ function searchCommands(ctx, query, isHidden) {
   const seen = /* @__PURE__ */ new Set();
   for (const command of ctx.commands.list()) {
     if (isHidden(command.id) || !ctx.commands.isEnabled(command.id)) continue;
-    const label2 = ctx.t(command.label).toLocaleLowerCase();
+    const label3 = ctx.t(command.label).toLocaleLowerCase();
     const english = command.label.toLocaleLowerCase();
-    const haystack = `${label2} ${english} ${command.id.replace(/[.-]/g, " ")}`;
+    const haystack = `${label3} ${english} ${command.id.replace(/[.-]/g, " ")}`;
     if (!words2.every((word) => haystack.includes(word))) continue;
-    if (seen.has(label2)) continue;
-    seen.add(label2);
-    const score = label2.startsWith(words2[0]) ? 0 : label2.includes(words2[0]) ? 1 : 2;
+    if (seen.has(label3)) continue;
+    seen.add(label3);
+    const score = label3.startsWith(words2[0]) ? 0 : label3.includes(words2[0]) ? 1 : 2;
     scored.push({ command, score });
   }
   return scored.sort(
@@ -32439,4 +34152,4 @@ function applyThemeColors(host, previous, colors) {
   return Object.keys(vars);
 }
 
-export { ACCOUNTING_FORMATS, ALL_RANGE, AUTOSUM_FUNCTIONS, BORDER_PRESETS, CATEGORIES, COLOR_SCALES, COMMAND_TABLES, CORE_FEATURE_STRINGS, CellViewCache, DATA_BAR_COLORS, DATE_CODES, DEFAULT_OPTIONS, DirtyState, EDITOR_LOCALES, EDITOR_THEME_MODES, FONT_NAMES, FONT_SIZES, FORMAT_CELLS_STRINGS, FRACTION_CODES, FUNCTION_MENUS, GridGeometry, HIGHLIGHT_STYLES, ICON_ACCENTS, ICON_PATHS, ICON_SETS, MARGIN_PRESETS, MESSAGE_STRINGS, MORE_FUNCTION_CATEGORIES, NAVIGATION_STRINGS, ORIENTATIONS, PAPER_SIZES, QUADRANTS, RIBBON_HOME_STRINGS, RIBBON_TAB_STRINGS, RULES_STRINGS, SHEET_ICONS, SPECIAL_CODES, STRINGS, SYMBOLS, SheetSelections, TABLE_STYLES, TEMPLATES, THEME_KEYS, TIME_CODES, TOOLS_STRINGS, UNSET, absoluteReference, activeChart, activeRef, activeStyle, activeTable, addRange, alignItems, alignmentCommands, applyThemeColors, autoSumRange, buildChart, buildCode, buildItems, cellCommands, cellMenu, cellRange3 as cellRange, cellStyleItems, clampAddress, clipState, clipboardCommands, colSelected, colorScaleRule, colsOf, colsRange, columnHeaderHeight, columnHeaderMenu, commandStrings, contextualCommands, createCommandRegistry, createDialogRegistry, createEditBridge, createSelectionModel, createTemplateWorkbook, cssFont, cssFontFamily, darkTheme, dataBarRule, dataCommands, detectCategory, diagonalSvg, dxfCss, edgeCss, editBridge, editChart, editing, editingCommands, evaluateRef, expandForMerges, extendSelection, fillPaint, fillSource, fillTemplate, findDefinedName2 as findDefinedName, findSpecial, fitNumber2 as fitNumber, fontCommands, formatNumber2 as formatNumber, formulaCommands, functionsIn, guessHeader, hasBorders, hasWorkbook, hashes, helpTab, historyOf, icon, iconCount, iconSetRule, iconSvg, iconThresholds, initialSelection, insertFunctionCall, installFormatPainter, isBlankView, isMenuSeparator, isSingleCell, isTabHidden, isWholeCols, isWholeRows2 as isWholeRows, justify, lightTheme, measure, moveWithinSelection, movingEnd, nameForRange, negativeCodes, normalizeEditorLocale, normalizeThemeMode, noteFunctionUse, numberCommands, numberFormatOptions, onRibbonTabsChange, pageLayoutCommands, parseBorderArg, parseSelectionRef, parseSheetReference, pasteWith, patternImage, pickColor, rangeRef, recentFunctions, refresh, regionOf, registerRibbonTabs, repeatToFill, resetRibbonTabs, resolveNameBox, reviewTab, ribbonTabs, rowHeaderMenu, rowHeaderWidth, rowSelected, rowsOf, rowsRange, scrollToReveal, searchCommands, selectCell, selectSpecial, selectTab, selectionCellCount, selectionRef, setTabHidden, sheetBaseName, sheetLocked, sortCommands, span3 as span, spanRange, stepFontSize, structureLocked, style, styleCssFont, tabButton, tabMenu, tableAt, tableStyleColor, tableStylePreview, target, textAlign, textDecoration, themePaletteItems, themeToCssVars, translate, translator, viewTab, viewing, wholeColumns, wholeRows, withTarget };
+export { ACCOUNTING_FORMATS, ALL_RANGE, AUTOSUM_FUNCTIONS, BORDER_PRESETS, CATEGORIES, COLOR_SCALES, COMMAND_TABLES, CORE_FEATURE_STRINGS, CellViewCache, DATA_BAR_COLORS, DATE_CODES, DEFAULT_OPTIONS, DirtyState, EDITOR_LOCALES, EDITOR_THEME_MODES, FONT_NAMES, FONT_SIZES, FORMAT_CELLS_STRINGS, FRACTION_CODES, FUNCTION_MENUS, GridGeometry, HIGHLIGHT_STYLES, ICON_ACCENTS, ICON_PATHS, ICON_SETS, MARGIN_PRESETS, MESSAGE_STRINGS, MORE_FUNCTION_CATEGORIES, NAVIGATION_STRINGS, ORIENTATIONS, PAPER_SIZES, QUADRANTS, RIBBON_HOME_STRINGS, RIBBON_TAB_STRINGS, RULES_STRINGS, SHEET_ICONS, SPECIAL_CODES, STRINGS, SYMBOLS, SheetSelections, TABLE_STYLES, TEMPLATES, THEME_KEYS, TIME_CODES, TOOLS_STRINGS, UNSET, absoluteReference, activeChart, activeRef, activeStyle, activeTable, addRange, alignItems, alignmentCommands, applyThemeColors, autoSumRange, buildChart, buildCode, buildItems, cellCommands, cellMenu, cellRange3 as cellRange, cellStyleItems, clampAddress, clipState, clipboardCommands, colSelected, colorScaleRule, colsOf, colsRange, columnHeaderHeight, columnHeaderMenu, commandStrings, contextualCommands, createCommandRegistry, createDialogRegistry, createEditBridge, createSelectionModel, createTemplateWorkbook, cssFont, cssFontFamily, darkTheme, dataBarRule, dataCommands, detectCategory, diagonalSvg, dxfCss, edgeCss, editBridge, editChart, editing, editingCommands, evaluateRef, expandForMerges, extendSelection, fillPaint, fillSource, fillTemplate, findDefinedName2 as findDefinedName, findSpecial, fitNumber2 as fitNumber, fontCommands, formatNumber2 as formatNumber, formulaCommands, functionsIn, guessHeader, hasBorders, hasWorkbook, hashes, helpTab, historyOf, icon, iconCount, iconSetRule, iconSvg, iconThresholds, initialSelection, insertFunctionCall, installFormatPainter, isBlankView, isMenuSeparator, isSingleCell, isTabHidden, isWholeCols, isWholeRows2 as isWholeRows, justify, lightTheme, measure, moveWithinSelection, movingEnd, nameForRange, negativeCodes, normalizeEditorLocale, normalizeThemeMode, noteFunctionUse, numberCommands, numberFormatOptions, onRibbonTabsChange, pageBreakCommands, pageLayoutCommands, parseBorderArg, parseSelectionRef, parseSheetReference, pasteWith, patternImage, pickColor, rangeRef, recentFunctions, refresh, regionOf, registerRibbonTabs, repeatToFill, resetRibbonTabs, resolveNameBox, reviewTab, ribbonTabs, rowHeaderMenu, rowHeaderWidth, rowSelected, rowsOf, rowsRange, scrollToReveal, searchCommands, selectCell, selectSpecial, selectTab, selectionCellCount, selectionRef, setTabHidden, sheetBaseName, sheetLocked, sortCommands, span3 as span, spanRange, stepFontSize, structureLocked, style, styleCssFont, tabButton, tabMenu, tableAt, tableStyleColor, tableStylePreview, target, textAlign, textDecoration, themePaletteItems, themeToCssVars, translate, translator, viewTab, viewing, wholeColumns, wholeRows, withTarget };