ooxml-core 1.8.4 → 1.10.0

package/dist/xlsx/ui/index.cjs

@@ -29,19 +29,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}`;
@@ -353,23 +353,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
@@ -855,7 +855,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: [],
@@ -863,31 +863,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];
@@ -922,29 +922,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") {
@@ -953,12 +953,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 };
 }
@@ -1099,15 +1099,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) {
@@ -1140,40 +1140,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) };
@@ -1866,9 +1866,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 ? "# ?/?" : "# ??/??"
@@ -11161,13 +11161,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(
@@ -11844,7 +11858,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;
@@ -11858,9 +11872,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;
@@ -11884,11 +11898,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 };
@@ -13621,12 +13635,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 {
@@ -13637,12 +13653,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 xmldom.XMLSerializer().serializeToString(node);
@@ -13718,6 +13734,649 @@ 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
+  ];
+  const extras = pivot.additionalValues ?? [];
+  if (pivot.valuesAxis !== void 0 && !["columns", "rows"].includes(pivot.valuesAxis))
+    throw new Error("Choose a valid Values axis.");
+  if (pivot.valuesPosition !== void 0 && !["last", "between", "first"].includes(pivot.valuesPosition))
+    throw new Error("Choose a valid Values position.");
+  if ((pivot.valuesPosition === "between" || pivot.valuesPosition === "first") && (pivot.valuesAxis !== "rows" || !pivot.secondRowField))
+    throw new Error("Values before or between fields require two row fields and Values on rows.");
+  if (pivot.valuesAxis === "rows" && (!Array.isArray(extras) || !extras.length))
+    throw new Error("Values on rows require multiple measures.");
+  if (extras.length > 0 && pivot.sourceXml && parseXml(pivot.sourceXml).documentElement.getAttribute("dataCaption") !== "Values")
+    throw new Error("This PivotTable uses unsupported Values header captions.");
+  if (!Array.isArray(extras) || extras.length > 15 || extras.some(
+    (measure2) => !measure2 || !pivot.fields.includes(measure2.field) || !PIVOT_AGGREGATES.includes(measure2.aggregate) || typeof measure2.caption !== "string" || !measure2.caption.trim() || measure2.caption.length > 255 || pivot.fields.some((field) => field.toLowerCase() === measure2.caption.toLowerCase())
+  ) || new Set(
+    [pivot.valueCaption, ...extras.map((measure2) => measure2.caption)].map(
+      (caption) => caption?.toLowerCase()
+    )
+  ).size !== extras.length + 1)
+    throw new Error("Choose PivotTable value fields with valid aggregates and unique captions.");
+  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/measures.ts
+var pivotMeasures = (pivot) => [
+  { field: pivot.valueField, aggregate: pivot.aggregate, caption: pivot.valueCaption },
+  ...pivot.additionalValues ?? []
+];
+function normalizedPivotMeasures(values2) {
+  if (!Array.isArray(values2) || values2.length > 15)
+    throw new Error("Choose between one and sixteen PivotTable value fields.");
+  return values2.map((value2) => {
+    if (!value2 || typeof value2.field !== "string")
+      throw new Error("Choose valid PivotTable value fields.");
+    const aggregate3 = value2.aggregate ?? "sum";
+    if (!PIVOT_AGGREGATES.includes(aggregate3))
+      throw new Error("Choose a valid PivotTable aggregate.");
+    return {
+      field: value2.field,
+      aggregate: aggregate3,
+      caption: value2.caption ?? `${aggregate3[0].toUpperCase()}${aggregate3.slice(1)} of ${value2.field}`
+    };
+  });
+}
+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;
+}
+var pivotMeasureNumber = (pivot, records, measure2) => aggregate2(records, pivot.fields.indexOf(measure2.field), measure2.aggregate);
+var pivotNumbers = (pivot, records) => pivotMeasures(pivot).map((measure2) => pivotMeasureNumber(pivot, records, measure2));
+function pivotHeaderDimensions(pivot, columnItems, rowLabels) {
+  const measures = 1 + (pivot.additionalValues?.length ?? 0);
+  if (pivot.valuesAxis === "rows")
+    return {
+      rows: pivot.columnField ? 2 : 1,
+      width: rowLabels + (pivot.columnField ? columnItems + 1 : 1)
+    };
+  return {
+    rows: pivot.columnField ? measures > 1 ? 3 : 2 : 1,
+    width: rowLabels + (pivot.columnField ? measures === 1 ? Math.max(1, columnItems) + 1 : (columnItems + 1) * measures : measures)
+  };
+}
+function pivotHeaders(pivot, columns, labels, label3) {
+  const measures = pivotMeasures(pivot);
+  if (pivot.valuesAxis === "rows") {
+    const rowLabels = pivot.layout === "compact" ? ["Row Labels"] : pivot.valuesPosition === "first" ? ["Values", ...labels] : pivot.valuesPosition === "between" ? [labels[0], "Values", labels[1]] : [...labels, "Values"];
+    return pivot.columnField ? [
+      [
+        ...rowLabels.map(() => null),
+        pivot.layout === "compact" ? "Column Labels" : pivot.columnField,
+        ...columns.map(() => null)
+      ],
+      [...rowLabels, ...columns.map(label3), "Grand Total"]
+    ] : [[...rowLabels, null]];
+  }
+  if (!pivot.columnField) return [[...labels, ...measures.map((measure2) => measure2.caption)]];
+  if (measures.length === 1)
+    return [
+      [
+        pivot.valueCaption,
+        ...labels.slice(1).map(() => null),
+        pivot.layout === "compact" ? "Column Labels" : pivot.columnField,
+        ...columns.slice(1).map(() => null),
+        null
+      ],
+      [...labels, ...columns.map(label3), "Grand Total"]
+    ];
+  const { width } = pivotHeaderDimensions(pivot, columns.length, labels.length);
+  const first2 = Array(width).fill(null);
+  first2[labels.length] = pivot.layout === "compact" ? "Column Labels" : pivot.columnField;
+  if (pivot.layout !== "compact") first2[labels.length + 1] = "Values";
+  return [
+    first2,
+    [
+      ...labels.map(() => null),
+      ...columns.flatMap((column) => [label3(column), ...measures.slice(1).map(() => null)]),
+      ...measures.map((measure2) => `Total ${measure2.caption}`)
+    ],
+    [
+      ...labels,
+      ...columns.flatMap(() => measures.map((measure2) => measure2.caption)),
+      ...measures.map(() => null)
+    ]
+  ];
+}
+
+// xlsx/pivot/hierarchy-first.ts
+function appendFirstPivotValues(pivot, context) {
+  const {
+    rowItems,
+    secondRowItems,
+    columnItems,
+    children: children2,
+    innerIndices,
+    groups,
+    details,
+    buckets,
+    width,
+    rowLabels,
+    top,
+    bottom,
+    append
+  } = context;
+  const compact3 = pivot.layout === "compact";
+  const tabular = !pivot.layout || pivot.layout === "tabular";
+  const blank = () => Array(width - rowLabels).fill(null);
+  pivotMeasures(pivot).forEach((measure2, m) => {
+    const numbers3 = (keys, records) => [
+      ...columnItems.map(
+        (column) => pivotMeasureNumber(
+          pivot,
+          buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+          measure2
+        )
+      ),
+      pivotMeasureNumber(pivot, records, measure2)
+    ];
+    if (!tabular)
+      append([measure2.caption, ...Array(rowLabels - 1).fill(null)], blank(), {
+        indices: [m],
+        measure: m
+      });
+    let first2 = true;
+    rowItems.forEach((outer, outerIndex) => {
+      const key = pivotValueKey(outer);
+      const group = groups.get(key) ?? [];
+      if (!tabular)
+        append(
+          compact3 ? [pivotItemLabel(outer)] : [null, pivotItemLabel(outer), null],
+          top ? numbers3([key], group) : blank(),
+          { indices: [m, outerIndex], measure: m },
+          compact3 ? 1 : 0
+        );
+      const innerKeys = [...children2.get(key)].sort(
+        (a, b) => innerIndices.get(a) - innerIndices.get(b)
+      );
+      innerKeys.forEach((innerKey, child) => {
+        const innerIndex = innerIndices.get(innerKey);
+        append(
+          compact3 ? [pivotItemLabel(secondRowItems[innerIndex])] : [
+            tabular && first2 ? measure2.caption : null,
+            pivot.repeatLabels || tabular && child === 0 ? pivotItemLabel(outer) : null,
+            pivotItemLabel(secondRowItems[innerIndex])
+          ],
+          numbers3([key, innerKey], details.get(JSON.stringify([key, innerKey]))),
+          { indices: [m, outerIndex, innerIndex], measure: m },
+          compact3 ? 2 : 0
+        );
+        first2 = false;
+      });
+      if (bottom)
+        append(
+          compact3 ? [`${String(pivotItemLabel(outer))} Total`] : [null, `${String(pivotItemLabel(outer))} Total`, null],
+          numbers3([key], group),
+          { indices: [m, outerIndex], measure: m, type: "default" },
+          compact3 ? 1 : 0
+        );
+    });
+  });
+}
+
+// xlsx/pivot/hierarchy.ts
+var label2 = pivotItemLabel;
+function hierarchicalPivotGrid(pivot) {
+  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 layout2 = pivot.layout ?? "tabular";
+  const compact3 = layout2 === "compact";
+  const rowsAxis = pivot.valuesAxis === "rows";
+  const firstValues = rowsAxis && pivot.valuesPosition === "first";
+  const between = rowsAxis && pivot.valuesPosition === "between";
+  const measures = pivotMeasures(pivot);
+  const top = (!rowsAxis || firstValues) && layout2 !== "tabular" && pivot.subtotals !== false && (pivot.subtotalPosition ?? "top") === "top";
+  const bottom = pivot.subtotals !== false && !top;
+  const rowLabelColumns = compact3 ? 1 : rowsAxis ? 3 : 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 dimensions = pivotHeaderDimensions(pivot, columnItems.length, rowLabelColumns);
+  const rows2 = (details.size + rowItems.length * Number(bottom) + 1) * (rowsAxis ? measures.length : 1) + rowItems.length * Number(layout2 !== "tabular") * (firstValues ? measures.length : 1) + (firstValues ? measures.length : between ? rowItems.length * measures.length : details.size) * Number(rowsAxis && layout2 !== "tabular") + dimensions.rows;
+  if (rows2 * dimensions.width > 1e6) throw new Error("The PivotTable result is too large.");
+  const labels = compact3 ? ["Row Labels"] : [pivot.rowField, pivot.secondRowField];
+  const values2 = pivotHeaders(pivot, columnItems, labels, label2);
+  const firstDataRow = values2.length;
+  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 bands = (keys, records) => [
+    ...columnItems.map(
+      (column) => pivotNumbers(pivot, buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [])
+    ),
+    pivotNumbers(pivot, records)
+  ];
+  const numbers3 = (keys, records) => bands(keys, records).flat();
+  const appendMeasures = (labels2, keys, records, indices, type) => {
+    const values3 = bands(keys, records);
+    measures.forEach(
+      (measure2, m) => append(
+        type ? [
+          `${type === "grand" ? "Total" : String(labels2[0])} ${measure2.caption}`,
+          ...Array(rowLabelColumns - 1).fill(null)
+        ] : compact3 ? [measure2.caption] : [
+          ...labels2.map(
+            (label3) => layout2 === "tabular" && m === 0 || pivot.repeatLabels ? label3 : null
+          ),
+          measure2.caption
+        ],
+        values3.map((band) => band[m] ?? null),
+        { indices: type ? indices : [...indices, m], measure: m, ...type ? { type } : {} },
+        compact3 && !type ? 2 : 0
+      )
+    );
+  };
+  if (firstValues)
+    appendFirstPivotValues(pivot, {
+      rowItems,
+      secondRowItems,
+      columnItems,
+      children: children2,
+      innerIndices,
+      groups,
+      details,
+      buckets,
+      width: dimensions.width,
+      rowLabels: rowLabelColumns,
+      top,
+      bottom,
+      append
+    });
+  else
+    rowItems.forEach((outer, outerIndex) => {
+      const key = pivotValueKey(outer);
+      if (layout2 !== "tabular")
+        append(
+          [label2(outer), ...Array(rowLabelColumns - 1).fill(null)],
+          top ? numbers3([key], groups.get(key) ?? []) : Array(dimensions.width - rowLabelColumns).fill(null),
+          { indices: [outerIndex] }
+        );
+      let first2 = true;
+      const innerKeys = [...children2.get(key)].sort(
+        (a, b) => innerIndices.get(a) - innerIndices.get(b)
+      );
+      if (between)
+        measures.forEach((measure2, m) => {
+          if (layout2 !== "tabular")
+            append(
+              compact3 ? [measure2.caption] : [pivot.repeatLabels ? label2(outer) : null, measure2.caption, null],
+              Array(dimensions.width - rowLabelColumns).fill(null),
+              { indices: [outerIndex, m], measure: m },
+              compact3 ? 1 : 0
+            );
+          innerKeys.forEach((innerKey, child) => {
+            const innerIndex = innerIndices.get(innerKey);
+            const keys = [key, innerKey];
+            const records = details.get(JSON.stringify(keys));
+            append(
+              compact3 ? [label2(secondRowItems[innerIndex])] : [
+                pivot.repeatLabels || layout2 === "tabular" && m === 0 && child === 0 ? label2(outer) : null,
+                layout2 === "tabular" && child === 0 ? measure2.caption : null,
+                label2(secondRowItems[innerIndex])
+              ],
+              [
+                ...columnItems.map(
+                  (column) => pivotMeasureNumber(
+                    pivot,
+                    buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+                    measure2
+                  )
+                ),
+                pivotMeasureNumber(pivot, records, measure2)
+              ],
+              { indices: [outerIndex, m, innerIndex], measure: m },
+              compact3 ? 2 : 0
+            );
+          });
+        });
+      else
+        innerKeys.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;
+          if (rowsAxis) {
+            if (layout2 !== "tabular")
+              append(
+                compact3 ? [label2(inner2)] : [pivot.repeatLabels ? label2(outer) : null, label2(inner2), null],
+                Array(dimensions.width - rowLabelColumns).fill(null),
+                { indices: [outerIndex, innerIndex] },
+                compact3 ? 1 : 0
+              );
+            appendMeasures(
+              [pivot.repeatLabels || first2 ? label2(outer) : null, label2(inner2)],
+              keys,
+              records,
+              [outerIndex, innerIndex]
+            );
+            first2 = false;
+            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) {
+        if (rowsAxis) {
+          appendMeasures([label2(outer)], [key], groups.get(key) ?? [], [outerIndex], "default");
+          return;
+        }
+        const caption = String(label2(outer));
+        append(
+          [`${caption} Total`, ...compact3 ? [] : [null]],
+          numbers3([key], groups.get(key) ?? []),
+          { indices: [outerIndex], type: "default" }
+        );
+      }
+    });
+  if (rowsAxis) appendMeasures([], [], pivot.records, [0], "grand");
+  else
+    append(["Grand Total", ...compact3 ? [] : [null]], numbers3([], pivot.records), {
+      indices: [0],
+      type: "grand"
+    });
+  return {
+    values: values2,
+    rowItems,
+    secondRowItems,
+    columnItems,
+    rowEntries,
+    firstDataRow,
+    rowLabelColumns,
+    indents,
+    ...rowsAxis ? { firstHeaderRow: 1 } : {}
+  };
+}
+
+// xlsx/pivot/aggregate.ts
+function pivotGrid(pivot) {
+  validatePivotFields(pivot);
+  if (pivot.secondRowField) return hierarchicalPivotGrid(pivot);
+  const rowItems = pivotItems(pivot, pivot.rowField);
+  const columnItems = pivot.columnField ? pivotItems(pivot, pivot.columnField) : [];
+  const rowsAxis = pivot.valuesAxis === "rows";
+  const compact3 = pivot.layout === "compact";
+  const headings = rowsAxis && pivot.layout !== void 0 && pivot.layout !== "tabular";
+  const dimensions = pivotHeaderDimensions(pivot, columnItems.length, rowsAxis && !compact3 ? 2 : 1);
+  const dataRows = (rowItems.length + 1) * (rowsAxis ? 1 + (pivot.additionalValues?.length ?? 0) : 1) + (headings ? rowItems.length : 0);
+  if ((dataRows + dimensions.rows) * dimensions.width > 1e6)
+    throw new Error("The PivotTable result is too large.");
+  const label3 = pivotItemLabel;
+  const values2 = pivotHeaders(
+    pivot,
+    columnItems,
+    [pivot.layout === "compact" ? "Row Labels" : pivot.rowField],
+    label3
+  );
+  const rowField = pivot.fields.indexOf(pivot.rowField);
+  const colField = pivot.columnField ? pivot.fields.indexOf(pivot.columnField) : -1;
+  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 firstDataRow = values2.length;
+  if (rowsAxis) {
+    const measures = pivotMeasures(pivot);
+    const rowEntries = [];
+    const indents = values2.map(() => 0);
+    const append = (caption, bands, index2, grand = false) => {
+      measures.forEach((measure2, m) => {
+        values2.push([
+          ...compact3 ? [grand ? `Total ${measure2.caption}` : measure2.caption] : [
+            grand ? `Total ${measure2.caption}` : pivot.repeatLabels || !headings && m === 0 ? caption : null,
+            grand ? null : measure2.caption
+          ],
+          ...bands.map((band) => band[m] ?? null)
+        ]);
+        indents.push(compact3 && !grand ? 1 : 0);
+        rowEntries.push({
+          indices: grand ? [0] : [index2, m],
+          measure: m,
+          ...grand ? { type: "grand" } : {}
+        });
+      });
+    };
+    rowItems.forEach((item, index2) => {
+      const key = pivotValueKey(item);
+      if (headings) {
+        values2.push([label3(item), ...Array(dimensions.width - 1).fill(null)]);
+        rowEntries.push({ indices: [index2] });
+        indents.push(0);
+      }
+      append(
+        label3(item),
+        [
+          ...columnItems.map(
+            (col) => pivotNumbers(pivot, cells.get(JSON.stringify([key, pivotValueKey(col)])) ?? [])
+          ),
+          pivotNumbers(pivot, groups.get(key) ?? [])
+        ],
+        index2
+      );
+    });
+    append(
+      "Grand Total",
+      [
+        ...columnItems.map((col) => pivotNumbers(pivot, columns.get(pivotValueKey(col)) ?? [])),
+        pivotNumbers(pivot, pivot.records)
+      ],
+      0,
+      true
+    );
+    return {
+      values: values2,
+      rowItems,
+      columnItems,
+      firstDataRow,
+      rowLabelColumns: compact3 ? 1 : 2,
+      indents,
+      firstHeaderRow: 1,
+      rowEntries
+    };
+  }
+  for (const row2 of rowItems) {
+    const records = groups.get(pivotValueKey(row2)) ?? [];
+    values2.push([
+      label3(row2),
+      ...columnItems.flatMap(
+        (col) => pivotNumbers(
+          pivot,
+          cells.get(JSON.stringify([pivotValueKey(row2), pivotValueKey(col)])) ?? []
+        )
+      ),
+      ...pivotNumbers(pivot, records)
+    ]);
+  }
+  values2.push([
+    "Grand Total",
+    ...columnItems.flatMap((col) => pivotNumbers(pivot, columns.get(pivotValueKey(col)) ?? [])),
+    ...pivotNumbers(pivot, pivot.records)
+  ]);
+  return { values: values2, rowItems, columnItems, firstDataRow };
+}
+
+// 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/read/style-parts.ts
 function parseColor(element2, palette) {
   if (!element2) return void 0;
@@ -14333,6 +14992,17 @@ function shiftFormulaInBand(formula, formulaSheet, sheet, shift2, band) {
   return changed ? tokens.map((t) => t.text).join("") : formula;
 }
 
+// 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 "";
+}
+
 // xlsx/layout/sparkline-view.ts
 var DEFAULTS = {
   colorSeries: "#376092",
@@ -14380,6 +15050,7 @@ function positions(group, data, n) {
       return dates.map((d) => d === null ? null : width ? (d - span4.min) / width : 0.5);
     }
   }
+  if (group.dateAxis) return Array.from({ length: n }, () => null);
   return Array.from({ length: n }, (_, i2) => n === 1 ? 0.5 : i2 / (n - 1));
 }
 function pointFacts(values2) {
@@ -14446,7 +15117,8 @@ function sparklineView(group, data, scale2, theme2) {
     });
     if (segment.length) view.lines.push(segment);
   } else {
-    const slot = 1 / n;
+    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) => {
@@ -14525,11 +15197,25 @@ function readSparklineValues(sheet, range2, displayHidden) {
 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;
+  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 dateValues ? { values: values2, dates: dateValues } : { values: values2 };
+    return { values: values2 };
   });
 }
 function sparklineViewAt(workbook, sheetIndex2, row2, col) {
@@ -14795,6 +15481,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)
@@ -15147,20 +15840,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);
@@ -15205,11 +15898,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",
@@ -15260,13 +15953,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";
@@ -15869,6 +16562,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)
@@ -15936,6 +16640,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) {
@@ -16178,13 +16889,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;
 }
@@ -16281,21 +16992,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>`);
   }
@@ -16355,12 +17066,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();
@@ -16386,7 +17097,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))
@@ -16402,16 +17113,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 = "";
@@ -16486,18 +17197,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, {
@@ -16527,17 +17238,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
@@ -18084,10 +18795,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);
@@ -18140,6 +18851,460 @@ 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 = new Map(
+        [.../* @__PURE__ */ new Set([0, ...grid6.indents ?? []])].map(
+          (indent) => [
+            indent,
+            stylePatcher(ctx.workbook, {
+              alignment: { indent, ...compact3 || indent > 0 ? { 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.get(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),
+    ...options.valuesAxis !== void 0 ? { valuesAxis: options.valuesAxis } : {},
+    ...options.valuesPosition !== void 0 ? { valuesPosition: options.valuesPosition } : {},
+    ...options.additionalValues ? { additionalValues: normalizedPivotMeasures(options.additionalValues) } : {},
+    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;
+  if (patch2.valuesAxis !== void 0) next.valuesAxis = patch2.valuesAxis;
+  if (patch2.valuesPosition !== void 0) next.valuesPosition = patch2.valuesPosition;
+  else if (patch2.valuesAxis === "columns" || patch2.secondRowField === "")
+    delete next.valuesPosition;
+  if (patch2.additionalValues !== void 0) {
+    const measures = normalizedPivotMeasures(patch2.additionalValues);
+    if (measures.length) next.additionalValues = measures;
+    else delete next.additionalValues;
+  }
+  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();
@@ -18247,19 +19412,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) => {
@@ -18485,6 +19650,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;
@@ -18507,17 +19674,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(
@@ -18528,25 +19695,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 }
   );
@@ -18728,28 +19895,28 @@ 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) {
+function setPrintOptions(ctx, s, patch2) {
   const sheet = sheetAt(ctx.workbook, s);
   ctx.run(
     "Print options",
     "view",
     [{ kind: "sheet", sheet: s }],
     () => {
-      const next = { ...sheet.printOptions, ...patch };
+      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;
@@ -18760,6 +19927,203 @@ function setPrintOptions(ctx, s, patch) {
   );
 }
 
+// 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
 var CANONICAL_BY_LOOKUP_KEY = {
   SHA1: "SHA-1",
@@ -20044,12 +21408,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;
@@ -20065,10 +21429,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;
@@ -20088,7 +21452,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);
@@ -20639,6 +22003,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(
@@ -20882,7 +22248,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(
@@ -21247,6 +22613,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",
@@ -21350,6 +22722,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 = [];
@@ -21426,6 +22809,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(
@@ -21652,68 +23037,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);
@@ -21726,8 +23049,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 ?? []] };
   };
@@ -21751,9 +23074,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;
@@ -21819,7 +23151,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),
@@ -21857,24 +23189,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),
@@ -21884,7 +23226,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) {
@@ -21899,12 +23241,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();
@@ -22859,21 +24201,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"],
@@ -23053,10 +24395,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 } : {},
@@ -23071,30 +24413,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,
@@ -24478,6 +25820,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"],
@@ -26614,6 +27974,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": [
@@ -27082,6 +28585,595 @@ 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 = {
+  "Before row fields": [
+    "Avant les champs de ligne",
+    "Vor den Zeilenfeldern",
+    "Antes de los campos de fila",
+    "\u884C\u5B57\u6BB5\u4E4B\u524D"
+  ],
+  "Values are listed before the row fields.": [
+    "Les valeurs sont affich\xE9es avant les champs de ligne.",
+    "Werte werden vor den Zeilenfeldern aufgef\xFChrt.",
+    "Los valores aparecen antes de los campos de fila.",
+    "\u503C\u5217\u5728\u884C\u5B57\u6BB5\u4E4B\u524D\u3002"
+  ],
+  "Values Placement:": [
+    "Position des valeurs :",
+    "Anordnung der Werte:",
+    "Posici\xF3n de los valores:",
+    "\u503C\u4F4D\u7F6E\uFF1A"
+  ],
+  "After row fields": [
+    "Apr\xE8s les champs de ligne",
+    "Nach den Zeilenfeldern",
+    "Despu\xE9s de los campos de fila",
+    "\u884C\u5B57\u6BB5\u4E4B\u540E"
+  ],
+  "Between row fields": [
+    "Entre les champs de ligne",
+    "Zwischen den Zeilenfeldern",
+    "Entre los campos de fila",
+    "\u884C\u5B57\u6BB5\u4E4B\u95F4"
+  ],
+  "Values are listed between the row fields.": [
+    "Les valeurs sont affich\xE9es entre les champs de ligne.",
+    "Werte werden zwischen den Zeilenfeldern aufgef\xFChrt.",
+    "Los valores aparecen entre los campos de fila.",
+    "\u503C\u5217\u5728\u884C\u5B57\u6BB5\u4E4B\u95F4\u3002"
+  ],
+  "Values Axis:": ["Axe des valeurs :", "Werteachse:", "Eje de valores:", "\u503C\u8F74\uFF1A"],
+  "Values on Columns": [
+    "Valeurs en colonnes",
+    "Werte in Spalten",
+    "Valores en columnas",
+    "\u503C\u663E\u793A\u5728\u5217\u4E0A"
+  ],
+  "Values on Rows": ["Valeurs en lignes", "Werte in Zeilen", "Valores en filas", "\u503C\u663E\u793A\u5728\u884C\u4E0A"],
+  "Values are listed after the row fields.": [
+    "Les valeurs sont affich\xE9es apr\xE8s les champs de ligne.",
+    "Werte werden nach den Zeilenfeldern aufgef\xFChrt.",
+    "Los valores aparecen despu\xE9s de los campos de fila.",
+    "\u503C\u5217\u5728\u884C\u5B57\u6BB5\u4E4B\u540E\u3002"
+  ],
+  "Values on rows display subtotals below groups.": [
+    "Les valeurs en lignes affichent les sous-totaux sous les groupes.",
+    "Werte in Zeilen zeigen Teilergebnisse unter den Gruppen an.",
+    "Los valores en filas muestran los subtotales debajo de los grupos.",
+    "\u884C\u4E0A\u7684\u503C\u5C06\u5206\u7C7B\u6C47\u603B\u663E\u793A\u5728\u7EC4\u4E0B\u65B9\u3002"
+  ],
+  "Multiple value fields use Values on columns.": [
+    "Plusieurs champs de valeur utilisent les valeurs en colonnes.",
+    "Mehrere Wertfelder verwenden Werte in Spalten.",
+    "Varios campos de valor usan Valores en columnas.",
+    "\u591A\u4E2A\u503C\u5B57\u6BB5\u7684\u503C\u4F4D\u4E8E\u5217\u8F74\u4E0A\u3002"
+  ],
+  "Add Value Field": [
+    "Ajouter un champ de valeur",
+    "Wertfeld hinzuf\xFCgen",
+    "A\xF1adir campo de valor",
+    "\u6DFB\u52A0\u503C\u5B57\u6BB5"
+  ],
+  "Remove Value Field": [
+    "Supprimer le champ de valeur",
+    "Wertfeld entfernen",
+    "Quitar campo de valor",
+    "\u5220\u9664\u503C\u5B57\u6BB5"
+  ],
+  "Additional Value Field": [
+    "Champ de valeur suppl\xE9mentaire",
+    "Zus\xE4tzliches Wertfeld",
+    "Campo de valor adicional",
+    "\u9644\u52A0\u503C\u5B57\u6BB5"
+  ],
+  "Value Caption:": ["Libell\xE9 de valeur :", "Wertbeschriftung:", "T\xEDtulo del valor:", "\u503C\u6807\u9898\uFF1A"],
+  "Multiple value fields use tabular layout with Values on columns.": [
+    "Plusieurs champs de valeur utilisent la forme tabulaire avec les valeurs en colonnes.",
+    "Mehrere Wertfelder verwenden das Tabellenformat mit Werten in Spalten.",
+    "Varios campos de valor usan el formato tabular con Valores en columnas.",
+    "\u591A\u4E2A\u503C\u5B57\u6BB5\u4F7F\u7528\u8868\u683C\u5E03\u5C40\uFF0C\u503C\u4F4D\u4E8E\u5217\u8F74\u4E0A\u3002"
+  ],
+  "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,
@@ -27107,7 +29199,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);
 
@@ -29284,9 +31379,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) => {
@@ -29325,47 +31420,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") }
       }
     }
   ]
@@ -29422,13 +31517,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 };
@@ -29598,10 +31693,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"],
@@ -29640,8 +31735,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({
@@ -29687,9 +31782,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);
@@ -30072,9 +32167,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)
@@ -30125,16 +32220,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);
           });
         }
@@ -30175,9 +32270,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");
@@ -30448,7 +32543,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) })
     )
   ];
 }
@@ -30479,9 +32574,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 [
@@ -30614,6 +32709,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) => ({
@@ -30637,9 +32769,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`;
@@ -32312,13 +34444,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(
@@ -32580,6 +34712,7 @@ exports.noteFunctionUse = noteFunctionUse;
 exports.numberCommands = numberCommands;
 exports.numberFormatOptions = numberFormatOptions;
 exports.onRibbonTabsChange = onRibbonTabsChange;
+exports.pageBreakCommands = pageBreakCommands;
 exports.pageLayoutCommands = pageLayoutCommands;
 exports.parseBorderArg = parseBorderArg;
 exports.parseSelectionRef = parseSelectionRef;