ooxml-core 1.8.3 → 1.9.0

package/dist/teams/index.mjs

@@ -261,9 +261,9 @@ var init_namespaces = __esm({
   }
 });
 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 {
@@ -274,12 +274,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;
 }
 function named(element2, local, ns, lenient = true) {
@@ -913,19 +913,19 @@ var init_opc = __esm({
 
 // xlsx/address.ts
 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;
 }
 function parseAddress(ref) {
@@ -979,12 +979,13 @@ function formatRange(range) {
 function quoteSheetName(name) {
   return /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) && !parseAddress(name) ? name : `'${name.replace(/'/g, "''")}'`;
 }
-var MAX_ROW, MAX_COL, formatAddress, cellKey;
+var MAX_ROW, MAX_COL, formatAddress, rangeSize, cellKey;
 var init_address = __esm({
   "xlsx/address.ts"() {
     MAX_ROW = 1048575;
     MAX_COL = 16383;
     formatAddress = (address2) => `${columnLabel(address2.col)}${address2.row + 1}`;
+    rangeSize = (range) => (range.end.row - range.start.row + 1) * (range.end.col - range.start.col + 1);
     cellKey = (row2, col) => row2 * (MAX_COL + 1) + col;
   }
 });
@@ -2590,10 +2591,10 @@ function titleXml(context, title) {
 function labelOptionsXml(context, options) {
   return numberFormatXml(options.numberFormat) + shapePropertiesXml(context, options.spPr) + textBodyXml(context, options.txPr) + valXml("dLblPos", options.position) + valXml("showLegendKey", options.showLegendKey) + valXml("showVal", options.showValue) + valXml("showCatName", options.showCategoryName) + valXml("showSerName", options.showSeriesName) + valXml("showPercent", options.showPercent) + valXml("showBubbleSize", options.showBubbleSize) + (options.separator === void 0 ? "" : textElement("separator", options.separator));
 }
-function labelXml(context, label2) {
+function labelXml(context, label3) {
   return elementXml(
     "dLbl",
-    valXml("idx", label2.index) + valXml("delete", label2.deleted) + layoutXml(context, label2.layout) + chartTextXml(context, label2.tx, false) + labelOptionsXml(context, label2) + raw(context, label2.extLst)
+    valXml("idx", label3.index) + valXml("delete", label3.deleted) + layoutXml(context, label3.layout) + chartTextXml(context, label3.tx, false) + labelOptionsXml(context, label3) + raw(context, label3.extLst)
   );
 }
 function dataLabelsXml(context, labels) {
@@ -2601,7 +2602,7 @@ function dataLabelsXml(context, labels) {
   const leaderLines = labels.leaderLines ? elementXml("leaderLines", shapePropertiesXml(context, labels.leaderLines.spPr)) : "";
   return elementXml(
     "dLbls",
-    labels.labels.map((label2) => labelXml(context, label2)).join("") + valXml("delete", labels.deleted) + labelOptionsXml(context, labels) + valXml("showLeaderLines", labels.showLeaderLines) + leaderLines + raw(context, labels.extLst)
+    labels.labels.map((label3) => labelXml(context, label3)).join("") + valXml("delete", labels.deleted) + labelOptionsXml(context, labels) + valXml("showLeaderLines", labels.showLeaderLines) + leaderLines + raw(context, labels.extLst)
   );
 }
 var textElement, dataSourceXml;
@@ -2632,12 +2633,12 @@ function dataTableXml(context, table2) {
 }
 function displayUnitsXml(context, units) {
   if (!units) return "";
-  const label2 = units.label;
+  const label3 = units.label;
   return elementXml(
     "dispUnits",
-    valXml("custUnit", units.customUnit) + (units.customUnit === void 0 ? valXml("builtInUnit", units.builtInUnit) : "") + (label2 ? elementXml(
+    valXml("custUnit", units.customUnit) + (units.customUnit === void 0 ? valXml("builtInUnit", units.builtInUnit) : "") + (label3 ? elementXml(
       "dispUnitsLbl",
-      layoutXml(context, label2.layout) + chartTextXml(context, label2.tx, false) + shapePropertiesXml(context, label2.spPr) + textBodyXml(context, label2.txPr)
+      layoutXml(context, label3.layout) + chartTextXml(context, label3.tx, false) + shapePropertiesXml(context, label3.spPr) + textBodyXml(context, label3.txPr)
     ) : "") + raw(context, units.extLst)
   );
 }
@@ -2848,10 +2849,10 @@ function parseDisplayUnits(context, element2) {
   if (!element2) return void 0;
   reportUnmodelled(context, element2, DISPLAY_UNITS);
   const labelElement = cChild(element2, "dispUnitsLbl");
-  let label2;
+  let label3;
   if (labelElement) {
     reportUnmodelled(context, labelElement, DISPLAY_UNITS_LABEL);
-    label2 = assignDefined(
+    label3 = assignDefined(
       {},
       {
         layout: manualLayout(labelElement),
@@ -2866,7 +2867,7 @@ function parseDisplayUnits(context, element2) {
     {
       builtInUnit: cVal(element2, "builtInUnit"),
       customUnit: cNumber(context, element2, "custUnit"),
-      label: label2,
+      label: label3,
       extLst: extensionList(element2)
     }
   );
@@ -7265,10 +7266,11 @@ function usedRange(sheet) {
   if (maxRow < 0) return void 0;
   return { start: { row: minRow, col: minCol }, end: { row: maxRow, col: maxCol } };
 }
-var getCell;
+var getCell, getValue;
 var init_cells = __esm({
   "xlsx/cells.ts"() {
     getCell = (sheet, row2, col) => sheet.rows.get(row2)?.get(col);
+    getValue = (sheet, row2, col) => getCell(sheet, row2, col)?.value ?? null;
   }
 });
 
@@ -15812,13 +15814,27 @@ var init_text_regex = __esm({
         "REGEXEXTRACT",
         C36,
         "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 text = str(args[0]);
+          if (mode === 1) {
+            const matches2 = [];
+            for (const match3 of text.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(text);
+          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(
@@ -17497,7 +17513,7 @@ function definedNamesOf(workbook) {
   });
   return names2;
 }
-function workbookXml(workbook, sheets, activeTab, sourceXml) {
+function workbookXml(workbook, sheets, activeTab, sourceXml, pivotCachesXml) {
   const kept = /* @__PURE__ */ new Map();
   if (sourceXml) {
     try {
@@ -17541,7 +17557,7 @@ function workbookXml(workbook, sheets, activeTab, sourceXml) {
   const iterate = workbook.iterate ? ` iterate="1" iterateCount="${workbook.iterate.count}" iterateDelta="${workbook.iterate.delta}"` : "";
   const owned = ["fullCalcOnLoad", "calcId", "calcMode", "iterate", "iterateCount", "iterateDelta"];
   out += `<calcPr${copyAttrs(calc, owned)} calcId="191029"${mode}${iterate} fullCalcOnLoad="1"/>`;
-  out += raw2(KEPT_TAIL);
+  out += pivotCachesXml === void 0 ? raw2(KEPT_TAIL) : raw2(KEPT_TAIL.slice(0, 2)) + pivotCachesXml + raw2(KEPT_TAIL.slice(3));
   return `${out}</workbook>`;
 }
 var KEPT_BEFORE_SHEETS, KEPT_AFTER_SHEETS, KEPT_TAIL, copyAttrs;
@@ -17969,6 +17985,11 @@ function readHeaderFooter(node) {
 function readPageSetup(margins, setup, headerFooter, fitToPage) {
   const page = {};
   if (setup) {
+    if (/^(1|true)$/.test(att(setup, "useFirstPageNumber") ?? "")) {
+      page.firstPageNumber = numAttr(setup, "firstPageNumber") ?? 1;
+    }
+    const order = att(setup, "pageOrder");
+    if (order === "downThenOver" || order === "overThenDown") page.pageOrder = order;
     const orientation = att(setup, "orientation");
     if (orientation && ORIENTATIONS.has(orientation))
       page.orientation = orientation;
@@ -18466,9 +18487,9 @@ var init_gradient_preset_data = __esm({
 var init_gradient_presets = __esm({
   "drawingml/gradient-presets.ts"() {
     init_gradient_preset_data();
-    OFFICE_GRADIENT_PRESET_DATA.map(([label2], index2) => ({
+    OFFICE_GRADIENT_PRESET_DATA.map(([label3], index2) => ({
       id: index2 + 1,
-      label: label2
+      label: label3
     }));
   }
 });
@@ -18704,8 +18725,8 @@ function parseTable(xml, partName) {
       if (id !== void 0 && Number.isInteger(id) && id >= 0) column.sourceId = id;
       const fn = att(node, "totalsRowFunction");
       if (fn && fn !== "none") column.totalsRowFunction = fn;
-      const label2 = att(node, "totalsRowLabel");
-      if (label2 !== void 0) column.totalsRowLabel = label2;
+      const label3 = att(node, "totalsRowLabel");
+      if (label3 !== void 0) column.totalsRowLabel = label3;
       const calculated = xFirst(node, "calculatedColumnFormula");
       if (calculated) column.calculatedColumnFormula = stripFuturePrefixes(xText(calculated));
       return column;
@@ -18787,20 +18808,28 @@ function setupXml(sheet, page) {
   const source2 = snapshotElement(sheet, "pageSetup");
   const fit = page.fitToWidth !== void 0 || page.fitToHeight !== void 0;
   const pick2 = (p) => ({
+    firstPageNumber: p.firstPageNumber,
+    pageOrder: p.pageOrder,
     orientation: p.orientation,
     paperSize: p.paperSize,
     scale: p.scale,
     fitToWidth: p.fitToWidth,
     fitToHeight: p.fitToHeight
   });
-  const modelled = fit || page.orientation !== void 0 || page.paperSize !== void 0 || page.scale !== void 0;
+  const modelled = page.firstPageNumber !== void 0 || page.pageOrder !== void 0 || fit || page.orientation !== void 0 || page.paperSize !== void 0 || page.scale !== void 0;
   if (!source2 && !modelled) return "";
   if (source2) {
     const before = readPageSetup(void 0, source2, void 0, fit) ?? {};
     if (sameModel(pick2(before), pick2(page))) return snapshotXml(sheet, "pageSetup") ?? "";
   }
   const fitValues = fit ? { fitToWidth: page.fitToWidth, fitToHeight: page.fitToHeight } : {};
+  const numbering = page.firstPageNumber !== void 0 || !source2 || readPageSetup(void 0, source2, void 0, fit)?.firstPageNumber !== void 0 ? {
+    firstPageNumber: page.firstPageNumber,
+    useFirstPageNumber: page.firstPageNumber !== void 0 ? true : void 0
+  } : {};
   return `<pageSetup${mergedAttrs(source2, {
+    ...numbering,
+    pageOrder: page.pageOrder,
     paperSize: page.paperSize,
     scale: page.scale,
     ...fitValues,
@@ -18956,6 +18985,76 @@ var init_sheet_data = __esm({
   }
 });
 
+// xlsx/layout/sparkline-data.ts
+function resolveSparklineRange(workbook, sheet, formula) {
+  const ref = formula.trim().replace(/^=/, "");
+  const bang = ref.lastIndexOf("!");
+  let target = sheet;
+  if (bang >= 0) {
+    const raw2 = ref.slice(0, bang);
+    const name = /^'.*'$/.test(raw2) ? raw2.slice(1, -1).replace(/''/g, "'") : raw2;
+    target = sheetByName(workbook, name);
+  }
+  const range = parseRange(ref.slice(bang + 1).replace(/\$/g, ""));
+  return target && range ? { sheet: target, range: normalizeRange(range) } : void 0;
+}
+var init_sparkline_data = __esm({
+  "xlsx/layout/sparkline-data.ts"() {
+    init_address();
+    init_workbook();
+  }
+});
+
+// xlsx/write/chart-cache.ts
+function referenceValues(workbook, sheet, ref, maxCells = MAX_CHART_CACHE_CELLS) {
+  if (!ref) return void 0;
+  const target = resolveSparklineRange(workbook, sheet, ref);
+  if (!target) return void 0;
+  const { range } = target;
+  const count2 = rangeSize(range);
+  if (!Number.isSafeInteger(count2) || count2 < 1 || count2 > maxCells || range.end.row > MAX_ROW || range.end.col > MAX_COL)
+    return void 0;
+  const values2 = [];
+  for (let row2 = range.start.row; row2 <= range.end.row; row2++)
+    for (let col = range.start.col; col <= range.end.col; col++)
+      values2.push(getValue(target.sheet, row2, col));
+  return values2;
+}
+function categoryValue(value) {
+  if (value === null) return "";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "object") return value.error;
+  if (typeof value === "number" && !Number.isFinite(value)) return "";
+  return value;
+}
+function chartWithCurrentCaches(workbook, sheet, chart) {
+  return {
+    ...chart,
+    series: chart.series.map((series) => {
+      const values2 = referenceValues(workbook, sheet, series.valuesRef);
+      const categories = referenceValues(workbook, sheet, series.categoriesRef);
+      const name = referenceValues(workbook, sheet, series.nameRef, 1);
+      return {
+        ...series,
+        ...name === void 0 ? {} : { name: String(categoryValue(name[0] ?? null)) },
+        values: values2?.map(
+          (value) => typeof value === "number" && Number.isFinite(value) ? value : null
+        ) ?? series.values,
+        categories: categories?.map(categoryValue) ?? series.categories
+      };
+    })
+  };
+}
+var MAX_CHART_CACHE_CELLS;
+var init_chart_cache = __esm({
+  "xlsx/write/chart-cache.ts"() {
+    init_address();
+    init_cells();
+    init_sparkline_data();
+    MAX_CHART_CACHE_CELLS = 1e4;
+  }
+});
+
 // xlsx/write/vml-ids.ts
 function vmlIdmapBlocks(xml) {
   const blocks = [];
@@ -19447,7 +19546,10 @@ function writeSheetDrawing(ctx, sheet, partName, rels, sourceDrawing) {
     }
   }
   const target = sourceDrawing && !writer.has(sourceDrawing) ? sourceDrawing : writer.uniqueName((n) => `xl/drawings/drawing${n}.xml`, ctx.reserved);
-  if (!writeDrawing(writer, target, sheet.drawings, sourceDrawing)) return "";
+  const drawings = sheet.drawings.map(
+    (object) => object.kind === "chart" && (!object.partName || !source2?.has(object.partName)) ? chartWithCurrentCaches(ctx.workbook, sheet, object) : object
+  );
+  if (!writeDrawing(writer, target, drawings, sourceDrawing)) return "";
   return `<drawing r:id="${rels.add(RELATIONSHIP_TYPES.drawing, relativeTarget(partName, target))}"/>`;
 }
 var init_sheet_parts = __esm({
@@ -19457,6 +19559,7 @@ var init_sheet_parts = __esm({
     init_drawing3();
     init_package2();
     init_tables();
+    init_chart_cache();
     init_comments2();
     init_drawing();
     init_snapshot();
@@ -19676,6 +19779,8 @@ function writeWorksheet(ctx, sheet, index2, partName) {
     const ids = sourceRelIds(source2, sheet.partName);
     for (const [id, rel] of source2.rels(sheet.partName)) {
       const target = source2.target(sheet.partName, rel);
+      if (rel.type === RELATIONSHIP_TYPES.pivotTable && target && sheet.preserved.get("source:pivotTables")?.includes(target))
+        continue;
       if (rel.type === RELATIONSHIP_TYPES.drawing && id === ids.drawing) sourceDrawing = target;
       if (REGENERATED.has(rel.type) || rel.type === RELATIONSHIP_TYPES.vmlDrawing && id === ids.legacy)
         continue;
@@ -19730,6 +19835,7 @@ function writeWorksheet(ctx, sheet, index2, partName) {
   blocks.set("drawing", writeSheetDrawing(ctx, sheet, partName, rels, sourceDrawing));
   blocks.set("legacyDrawing", writeComments(ctx, sheet, index2, partName, rels));
   blocks.set("tableParts", tableParts);
+  ctx.pivots?.writeSheet(writer, sheet, partName, rels);
   blocks.set("extLst", conditionalExtensionsXml(sheet));
   for (const [key, list] of sheet.preserved) {
     if (key.startsWith("source:") || !ORDER2.includes(key) || (blocks.get(key) ?? "") !== "")
@@ -19815,6 +19921,532 @@ var init_worksheet2 = __esm({
   }
 });
 
+// xlsx/edit/sparkline-ranges.ts
+function checkedSparklineRange(raw2) {
+  const range = normalizeRange(raw2);
+  for (const point of [range.start, range.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 range;
+}
+function sparklineDataRange(workbook, sheet, source2) {
+  let ast;
+  try {
+    ast = parseFormula(source2.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 }) };
+}
+var init_sparkline_ranges = __esm({
+  "xlsx/edit/sparkline-ranges.ts"() {
+    init_address();
+    init_parser();
+  }
+});
+
+// xlsx/pivot/data.ts
+function pivotValueKey(value) {
+  return value === null || value === "" ? "blank" : isCellError(value) ? `error:${value.error}` : `${typeof value}:${String(value).toLowerCase()}`;
+}
+function pivotItems(pivot, field) {
+  const index2 = pivot.fields.indexOf(field);
+  const items = /* @__PURE__ */ new Map();
+  for (const record of pivot.records) {
+    const value = record[index2] ?? null;
+    const key = pivotValueKey(value);
+    if (!items.has(key)) items.set(key, value);
+  }
+  const rank3 = (value) => value === null || value === "" ? 4 : isCellError(value) ? 3 : typeof value === "boolean" ? 2 : typeof value === "string" ? 1 : 0;
+  return [...items.values()].sort(
+    (a2, b) => rank3(a2) - rank3(b) || (typeof a2 === "number" && typeof b === "number" ? a2 - b : String(pivotItemLabel(a2)).localeCompare(String(pivotItemLabel(b)), "en", {
+      sensitivity: "base",
+      numeric: true
+    }))
+  );
+}
+function pivotItemLabel(value) {
+  if (value === null || value === "") return "(blank)";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  return isCellError(value) ? value.error : value;
+}
+function validatePivotFields(pivot) {
+  const used = [
+    pivot.rowField,
+    ...pivot.secondRowField ? [pivot.secondRowField] : [],
+    ...pivot.columnField ? [pivot.columnField] : [],
+    pivot.valueField
+  ];
+  if (pivot.layout !== void 0 && !["tabular", "compact", "outline"].includes(pivot.layout) || pivot.subtotalPosition !== void 0 && !["top", "bottom"].includes(pivot.subtotalPosition) || !PIVOT_AGGREGATES.includes(pivot.aggregate) || used.some((field) => !pivot.fields.includes(field)) || new Set([pivot.rowField, pivot.secondRowField, pivot.columnField].filter(Boolean)).size !== [pivot.rowField, pivot.secondRowField, pivot.columnField].filter(Boolean).length || pivot.subtotals !== void 0 && typeof pivot.subtotals !== "boolean" || pivot.repeatLabels !== void 0 && typeof pivot.repeatLabels !== "boolean")
+    throw new Error("Choose valid PivotTable fields; row and column fields must differ.");
+}
+var PIVOT_AGGREGATES;
+var init_data = __esm({
+  "xlsx/pivot/data.ts"() {
+    init_model();
+    PIVOT_AGGREGATES = ["sum", "count", "average", "min", "max"];
+  }
+});
+
+// xlsx/pivot/cache-xml.ts
+function pivotCacheData(pivot) {
+  const items = pivot.fields.map(() => []);
+  const indices = pivot.fields.map(() => /* @__PURE__ */ new Map());
+  for (const record of pivot.records)
+    pivot.fields.forEach((_field, index2) => {
+      const value = record[index2] ?? null;
+      const key = pivotValueKey(value);
+      if (!indices[index2].has(key)) {
+        indices[index2].set(key, items[index2].length);
+        items[index2].push(value);
+      }
+    });
+  return { items, indices };
+}
+function valueXml(value) {
+  if (value === null || value === "") return "<m/>";
+  if (isCellError(value)) return `<e${attrs({ v: value.error })}/>`;
+  if (typeof value === "string") return `<s${attrs({ v: encodeEscapes(value) })}/>`;
+  if (typeof value === "boolean") return `<b v="${value ? 1 : 0}"/>`;
+  if (!Number.isFinite(value)) throw new Error("The PivotTable cache contains an invalid value.");
+  return `<n v="${value}"/>`;
+}
+function pivotCacheDefinitionXml(pivot, workbook, data, recordRel) {
+  const source2 = sparklineDataRange(workbook, 0, pivot.source);
+  const fields = pivot.fields.map((name, index2) => {
+    const items = data.items[index2];
+    const types = new Set(
+      items.map((value) => value === null || value === "" ? "blank" : typeof value)
+    );
+    const nums = items.filter((value) => typeof value === "number");
+    const text = items.some((item) => item !== null && item !== "" && typeof item !== "number");
+    return `<cacheField${attrs({ name: encodeEscapes(name), numFmtId: 0 })}><sharedItems${attrs({ count: items.length, containsString: !nums.length || text, containsNumber: !!nums.length, containsInteger: nums.length > 0 && nums.every(Number.isInteger), containsBlank: types.has("blank"), containsMixedTypes: nums.length > 0 && text, containsSemiMixedTypes: !nums.length || types.size > 1 })}>${items.map(valueXml).join("")}</sharedItems></cacheField>`;
+  }).join("");
+  return `${XML_HEADER}<pivotCacheDefinition xmlns="${NS.x}" xmlns:r="${NS.r}" r:id="${recordRel}" createdVersion="6" refreshedVersion="6" minRefreshableVersion="3" recordCount="${pivot.records.length}"><cacheSource type="worksheet"><worksheetSource${attrs({ ref: formatRange(source2.range), sheet: workbook.sheets[source2.sheet].name })}/></cacheSource><cacheFields count="${pivot.fields.length}">${fields}</cacheFields></pivotCacheDefinition>`;
+}
+function pivotCacheRecordsXml(pivot, data) {
+  const records = pivot.records.map(
+    (record) => `<r>${pivot.fields.map((_field, index2) => `<x v="${data.indices[index2].get(pivotValueKey(record[index2] ?? null))}"/>`).join("")}</r>`
+  ).join("");
+  return `${XML_HEADER}<pivotCacheRecords xmlns="${NS.x}" count="${pivot.records.length}">${records}</pivotCacheRecords>`;
+}
+var init_cache_xml = __esm({
+  "xlsx/pivot/cache-xml.ts"() {
+    init_xml2();
+    init_model();
+    init_address();
+    init_sparkline_ranges();
+    init_xml_out();
+    init_data();
+  }
+});
+
+// xlsx/pivot/hierarchy.ts
+function hierarchicalPivotGrid(pivot, aggregate3) {
+  const rowItems = pivotItems(pivot, pivot.rowField);
+  const secondRowItems = pivotItems(pivot, pivot.secondRowField);
+  const columnItems = pivot.columnField ? pivotItems(pivot, pivot.columnField) : [];
+  const outerField = pivot.fields.indexOf(pivot.rowField);
+  const innerField = pivot.fields.indexOf(pivot.secondRowField);
+  const columnField = pivot.columnField ? pivot.fields.indexOf(pivot.columnField) : -1;
+  const valueField = pivot.fields.indexOf(pivot.valueField);
+  const layout2 = pivot.layout ?? "tabular";
+  const compact = layout2 === "compact";
+  const top = layout2 !== "tabular" && pivot.subtotals !== false && (pivot.subtotalPosition ?? "top") === "top";
+  const bottom = pivot.subtotals !== false && !top;
+  const rowLabelColumns = compact ? 1 : 2;
+  const groups = /* @__PURE__ */ new Map();
+  const details = /* @__PURE__ */ new Map();
+  const children2 = /* @__PURE__ */ new Map();
+  const innerIndices = new Map(secondRowItems.map((item, index2) => [pivotValueKey(item), index2]));
+  const buckets = /* @__PURE__ */ new Map();
+  const collect = (map, key, record) => {
+    const list = map.get(key);
+    if (list) list.push(record);
+    else map.set(key, [record]);
+  };
+  for (const record of pivot.records) {
+    const outer = pivotValueKey(record[outerField] ?? null);
+    const inner = pivotValueKey(record[innerField] ?? null);
+    collect(groups, outer, record);
+    collect(details, JSON.stringify([outer, inner]), record);
+    if (!children2.has(outer)) children2.set(outer, /* @__PURE__ */ new Set());
+    children2.get(outer).add(inner);
+    if (pivot.columnField) {
+      const column = pivotValueKey(record[columnField] ?? null);
+      for (const key of [[], [outer], [outer, inner]])
+        collect(buckets, JSON.stringify([...key, column]), record);
+    }
+  }
+  const rows = details.size + rowItems.length * (Number(layout2 !== "tabular") + Number(bottom)) + 3;
+  if (rows * (columnItems.length + 3) > 1e6)
+    throw new Error("The PivotTable result is too large.");
+  const labels = compact ? ["Row Labels"] : [pivot.rowField, pivot.secondRowField];
+  const values2 = pivot.columnField ? [
+    [
+      pivot.valueCaption,
+      ...compact ? [] : [null],
+      compact ? "Column Labels" : pivot.columnField,
+      ...columnItems.slice(1).map(() => null),
+      null
+    ],
+    [...labels, ...columnItems.map(label2), "Grand Total"]
+  ] : [[...labels, pivot.valueCaption]];
+  const indents = values2.map(() => 0);
+  const rowEntries = [];
+  const append = (labels2, numbers4, entry3, indent = 0) => {
+    values2.push([...labels2, ...numbers4]);
+    rowEntries.push(entry3);
+    indents.push(indent);
+  };
+  const numbers3 = (keys, records) => [
+    ...columnItems.map(
+      (column) => aggregate3(
+        buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+        valueField,
+        pivot.aggregate
+      )
+    ),
+    aggregate3(records, valueField, pivot.aggregate)
+  ];
+  rowItems.forEach((outer, outerIndex) => {
+    const key = pivotValueKey(outer);
+    if (layout2 !== "tabular")
+      append(
+        [label2(outer), ...compact ? [] : [null]],
+        top ? numbers3([key], groups.get(key) ?? []) : Array(columnItems.length + 1).fill(null),
+        { indices: [outerIndex] }
+      );
+    let first2 = true;
+    [...children2.get(key)].sort((a2, b) => innerIndices.get(a2) - innerIndices.get(b)).forEach((innerKey) => {
+      const innerIndex = innerIndices.get(innerKey);
+      const inner = secondRowItems[innerIndex];
+      const keys = [key, innerKey];
+      const records = details.get(JSON.stringify(keys));
+      if (!records) return;
+      append(
+        compact ? [label2(inner)] : [
+          pivot.repeatLabels || layout2 === "tabular" && first2 ? label2(outer) : null,
+          label2(inner)
+        ],
+        numbers3(keys, records),
+        { indices: [outerIndex, innerIndex] },
+        compact ? 1 : 0
+      );
+      first2 = false;
+    });
+    if (bottom) {
+      const caption = String(label2(outer));
+      append(
+        [`${caption} Total`, ...compact ? [] : [null]],
+        numbers3([key], groups.get(key) ?? []),
+        { indices: [outerIndex], type: "default" }
+      );
+    }
+  });
+  append(["Grand Total", ...compact ? [] : [null]], numbers3([], pivot.records), {
+    indices: [0],
+    type: "grand"
+  });
+  return {
+    values: values2,
+    rowItems,
+    secondRowItems,
+    columnItems,
+    rowEntries,
+    firstDataRow: pivot.columnField ? 2 : 1,
+    rowLabelColumns,
+    indents
+  };
+}
+var label2;
+var init_hierarchy2 = __esm({
+  "xlsx/pivot/hierarchy.ts"() {
+    init_data();
+    label2 = pivotItemLabel;
+  }
+});
+
+// xlsx/pivot/aggregate.ts
+function aggregate2(records, field, type) {
+  if (!records.length) return null;
+  const values2 = records.map((record) => record[field] ?? null);
+  if (type === "count") return values2.filter((value) => value !== null && value !== "").length;
+  const error = values2.find(isCellError);
+  if (error) return error;
+  const numbers3 = values2.filter((value) => typeof value === "number");
+  if (!numbers3.length) return type === "average" ? { error: "#DIV/0!" } : 0;
+  if (type === "min") return numbers3.reduce((a2, b) => Math.min(a2, b));
+  if (type === "max") return numbers3.reduce((a2, b) => Math.max(a2, b));
+  const sum2 = numbers3.reduce((total2, value) => total2 + value, 0);
+  return type === "average" ? sum2 / numbers3.length : sum2;
+}
+function pivotGrid(pivot) {
+  validatePivotFields(pivot);
+  if (pivot.secondRowField) return hierarchicalPivotGrid(pivot, aggregate2);
+  const rowItems = pivotItems(pivot, pivot.rowField);
+  const columnItems = pivot.columnField ? pivotItems(pivot, pivot.columnField) : [];
+  if ((rowItems.length + 3) * (columnItems.length + 2) > 1e6)
+    throw new Error("The PivotTable result is too large.");
+  const rowField = pivot.fields.indexOf(pivot.rowField);
+  const colField = pivot.columnField ? pivot.fields.indexOf(pivot.columnField) : -1;
+  const valueField = pivot.fields.indexOf(pivot.valueField);
+  const groups = /* @__PURE__ */ new Map();
+  const cells2 = /* @__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(cells2, JSON.stringify([key, col]), record);
+    }
+  }
+  const label3 = pivotItemLabel;
+  const values2 = pivot.columnField ? [
+    [
+      pivot.valueCaption,
+      pivot.layout === "compact" ? "Column Labels" : pivot.columnField,
+      ...columnItems.slice(1).map(() => null),
+      null
+    ],
+    [
+      pivot.layout === "compact" ? "Row Labels" : pivot.rowField,
+      ...columnItems.map(label3),
+      "Grand Total"
+    ]
+  ] : [[pivot.layout === "compact" ? "Row Labels" : pivot.rowField, pivot.valueCaption]];
+  for (const row2 of rowItems) {
+    const records = groups.get(pivotValueKey(row2)) ?? [];
+    values2.push([
+      label3(row2),
+      ...columnItems.map(
+        (col) => aggregate2(
+          cells2.get(JSON.stringify([pivotValueKey(row2), pivotValueKey(col)])) ?? [],
+          valueField,
+          pivot.aggregate
+        )
+      ),
+      aggregate2(records, valueField, pivot.aggregate)
+    ]);
+  }
+  values2.push([
+    "Grand Total",
+    ...columnItems.map(
+      (col) => aggregate2(columns.get(pivotValueKey(col)) ?? [], valueField, pivot.aggregate)
+    ),
+    aggregate2(pivot.records, valueField, pivot.aggregate)
+  ]);
+  return { values: values2, rowItems, columnItems, firstDataRow: pivot.columnField ? 2 : 1 };
+}
+var init_aggregate = __esm({
+  "xlsx/pivot/aggregate.ts"() {
+    init_model();
+    init_data();
+    init_hierarchy2();
+  }
+});
+
+// xlsx/pivot/table-xml.ts
+function pivotTableXml(pivot, cacheId, cache2) {
+  const grid = pivotGrid(pivot);
+  const row2 = pivot.fields.indexOf(pivot.rowField);
+  const second = pivot.secondRowField ? pivot.fields.indexOf(pivot.secondRowField) : -1;
+  const col = pivot.columnField ? pivot.fields.indexOf(pivot.columnField) : -1;
+  const value = pivot.fields.indexOf(pivot.valueField);
+  const compact = pivot.layout === "compact";
+  const outline = pivot.layout === "compact" || pivot.layout === "outline";
+  const top = (pivot.subtotalPosition ?? (outline ? "top" : "bottom")) === "top";
+  const fields = pivot.fields.map((_field, index2) => {
+    const items2 = index2 === row2 ? grid.rowItems : index2 === second ? grid.secondRowItems : index2 === col ? grid.columnItems : void 0;
+    const subtotal = !(index2 === row2 && pivot.subtotals === false);
+    const repeated = pivot.repeatLabels && (index2 === row2 || index2 === second) ? '<extLst><ext uri="{2946ED86-A175-432a-8AC1-64E0C546D7DE}"><x14:pivotField xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" fillDownLabels="1"/></ext></extLst>' : "";
+    return `<pivotField${attrs({ axis: index2 === row2 || index2 === second ? "axisRow" : index2 === col ? "axisCol" : void 0, dataField: index2 === value ? true : void 0, compact, outline, showAll: false, subtotalTop: index2 === row2 ? top : void 0, defaultSubtotal: subtotal ? void 0 : false })}>${items2 ? `<items count="${items2.length + Number(subtotal)}">${items2.map((item) => `<item x="${cache2.indices[index2].get(pivotValueKey(item))}"/>`).join("")}${subtotal ? '<item t="default"/>' : ""}</items>` : ""}${repeated}</pivotField>`;
+  }).join("");
+  const items = (count2) => Array.from({ length: count2 }, (_v, i) => `<i><x v="${i}"/></i>`).join("") + '<i t="grand"><x/></i>';
+  const header = grid.firstDataRow - 1;
+  const rowIndices = [row2, ...second >= 0 ? [second] : []];
+  let previous = [];
+  const rowItems = grid.rowEntries?.map((entry3) => {
+    let prefix = 0;
+    if (!entry3.type)
+      while (prefix < entry3.indices.length - 1 && entry3.indices[prefix] === previous[prefix])
+        prefix++;
+    previous = entry3.type ? [] : entry3.indices;
+    return `<i${attrs({ t: entry3.type, r: prefix || void 0 })}>${entry3.indices.slice(prefix).map((index2) => `<x${attrs({ v: index2 || void 0 })}/>`).join("")}</i>`;
+  }).join("") ?? items(grid.rowItems.length);
+  let body = `<location${attrs({ ref: formatRange(pivot.location), firstHeaderRow: header, firstDataRow: grid.firstDataRow, firstDataCol: grid.rowLabelColumns ?? 1 })}/><pivotFields count="${pivot.fields.length}">${fields}</pivotFields><rowFields count="${rowIndices.length}">${rowIndices.map((index2) => `<field x="${index2}"/>`).join("")}</rowFields><rowItems count="${grid.rowEntries?.length ?? grid.rowItems.length + 1}">${rowItems}</rowItems>`;
+  if (col >= 0)
+    body += `<colFields count="1"><field x="${col}"/></colFields><colItems count="${grid.columnItems.length + 1}">${items(grid.columnItems.length)}</colItems>`;
+  else body += '<colItems count="1"><i><x/></i></colItems>';
+  body += `<dataFields count="1"><dataField${attrs({ name: encodeEscapes(pivot.valueCaption), fld: value, subtotal: pivot.aggregate, baseField: 0, baseItem: 0 })}/></dataFields>`;
+  const doc = parseXml(
+    pivot.sourceXml ?? `<pivotTableDefinition xmlns="${NS.x}" dataCaption="Values" updatedVersion="6" minRefreshableVersion="3" createdVersion="6"><pivotTableStyleInfo name="PivotStyleLight16" showRowHeaders="1" showColHeaders="1" showRowStripes="0" showColStripes="0" showLastColumn="1"/></pivotTableDefinition>`
+  );
+  const root = doc.documentElement;
+  root.setAttribute("name", pivot.name);
+  root.setAttribute("cacheId", String(cacheId));
+  root.setAttribute("compact", compact ? "1" : "0");
+  root.setAttribute("compactData", compact ? "1" : "0");
+  root.setAttribute("outline", outline ? "1" : "0");
+  root.setAttribute("outlineData", outline ? "1" : "0");
+  if (compact) root.setAttribute("indent", "0");
+  root.setAttribute("rowGrandTotals", "1");
+  root.setAttribute("colGrandTotals", "1");
+  for (const extension of elements(
+    first(root, "extLst", NS.x) ?? parseXml("<root/>").documentElement
+  )) {
+    const definition = first(
+      extension,
+      "pivotTableDefinition",
+      "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
+    );
+    if (definition?.hasAttribute("fillDownLabelsDefault"))
+      definition.setAttribute("fillDownLabelsDefault", pivot.repeatLabels ? "1" : "0");
+  }
+  const replaced = /* @__PURE__ */ new Set([
+    "location",
+    "pivotFields",
+    "rowFields",
+    "rowItems",
+    "colFields",
+    "colItems",
+    "dataFields"
+  ]);
+  for (const child3 of elements(root)) if (replaced.has(child3.localName)) root.removeChild(child3);
+  const replacement = parseXml(`<root xmlns="${NS.x}">${body}</root>`).documentElement;
+  const before = root.firstChild;
+  for (const child3 of elements(replacement)) root.insertBefore(doc.importNode(child3, true), before);
+  return XML_HEADER + buildXml(root);
+}
+var init_table_xml = __esm({
+  "xlsx/pivot/table-xml.ts"() {
+    init_xml2();
+    init_address();
+    init_xml_out();
+    init_aggregate();
+    init_data();
+  }
+});
+
+// xlsx/pivot/write.ts
+var TYPES, PivotWritePlan;
+var init_write = __esm({
+  "xlsx/pivot/write.ts"() {
+    init_opc();
+    init_xml2();
+    init_xml_util();
+    init_package_writer();
+    init_drawing();
+    init_cache_xml();
+    init_table_xml();
+    TYPES = {
+      table: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml",
+      definition: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml",
+      records: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"
+    };
+    PivotWritePlan = class {
+      tableParts = /* @__PURE__ */ new Map();
+      cachesXml;
+      constructor(writer, workbook, source2, bookPart, bookRels, reserved) {
+        const sourceCaches = source2?.text(bookPart) ? children(
+          first(parseXml(source2.text(bookPart)).documentElement, "pivotCaches", NS.x) ?? parseXml("<root/>").documentElement,
+          "pivotCache",
+          NS.x
+        ) : [];
+        const retained = /* @__PURE__ */ new Set();
+        const owns = workbook.sheets.some((sheet) => sheet.pivotTables !== void 0);
+        for (const sheet of workbook.sheets)
+          if (source2 && sheet.partName)
+            for (const rel of source2.rels(sheet.partName).values()) {
+              if (rel.type !== RELATIONSHIP_TYPES.pivotTable) continue;
+              const part = source2.target(sheet.partName, rel);
+              if (!part) continue;
+              const pivot = sheet.pivotTables?.find((entry3) => entry3.partName === part);
+              if (pivot?.dirty || !pivot && sheet.preserved.get("source:pivotTables")?.includes(part))
+                continue;
+              const xml = source2.text(part);
+              if (xml) retained.add(Number(parseXml(xml).documentElement.getAttribute("cacheId")));
+            }
+        const entries = [];
+        for (const node of sourceCaches) {
+          const id = Number(node.getAttribute("cacheId"));
+          if (owns && !retained.has(id)) continue;
+          const rid = relAttr(node, "id");
+          const rel = rid && source2?.rels(bookPart).get(rid);
+          const part = rel && source2?.target(bookPart, rel);
+          if (rel && rid && part) {
+            bookRels.keep(rid, rel);
+            writer.carry(part);
+            entries.push(selfContainedXml(node));
+          }
+        }
+        let cacheId = Math.max(
+          -1,
+          ...sourceCaches.map((node) => Number(node.getAttribute("cacheId"))).filter((id) => Number.isInteger(id) && id >= 0)
+        ) + 1;
+        for (const sheet of workbook.sheets)
+          for (const pivot of sheet.pivotTables ?? []) {
+            if (pivot.partName && !pivot.dirty) {
+              this.tableParts.set(pivot, pivot.partName);
+              continue;
+            }
+            const table2 = pivot.partName ?? writer.uniqueName((n) => `xl/pivotTables/pivotTable${n}.xml`, reserved);
+            const definition = writer.uniqueName(
+              (n) => `xl/pivotCache/pivotCacheDefinition${n}.xml`,
+              reserved
+            );
+            const records = writer.uniqueName(
+              (n) => `xl/pivotCache/pivotCacheRecords${n}.xml`,
+              reserved
+            );
+            const cache2 = pivotCacheData(pivot);
+            const cacheRels = new RelationshipSet();
+            const recordRel = cacheRels.add(
+              `${NS.r}/pivotCacheRecords`,
+              relativeTarget(definition, records)
+            );
+            writer.add(records, pivotCacheRecordsXml(pivot, cache2), TYPES.records);
+            writer.add(
+              definition,
+              pivotCacheDefinitionXml(pivot, workbook, cache2, recordRel),
+              TYPES.definition
+            );
+            writer.rels(definition, cacheRels);
+            writer.add(table2, pivotTableXml(pivot, cacheId, cache2), TYPES.table);
+            const tableRels = new RelationshipSet();
+            tableRels.add(RELATIONSHIP_TYPES.pivotCacheDefinition, relativeTarget(table2, definition));
+            writer.rels(table2, tableRels);
+            const rid = bookRels.add(
+              RELATIONSHIP_TYPES.pivotCacheDefinition,
+              relativeTarget(bookPart, definition)
+            );
+            entries.push(`<pivotCache cacheId="${cacheId++}" r:id="${rid}"/>`);
+            this.tableParts.set(pivot, table2);
+          }
+        this.cachesXml = owns ? entries.length ? `<pivotCaches>${entries.join("")}</pivotCaches>` : "" : void 0;
+      }
+      writeSheet(writer, sheet, part, rels) {
+        for (const pivot of sheet.pivotTables ?? []) {
+          const table2 = this.tableParts.get(pivot);
+          writer.carry(table2);
+          rels.add(RELATIONSHIP_TYPES.pivotTable, relativeTarget(part, table2));
+        }
+      }
+    };
+  }
+});
+
 // xlsx/write/save.ts
 async function saveXlsx(workbook) {
   if (!workbook.sheets.length) throw new Error("A workbook needs at least one sheet");
@@ -19857,6 +20489,7 @@ async function saveXlsx(workbook) {
       if (target) writer.carry(target);
     }
   }
+  ctx.pivots = new PivotWritePlan(writer, workbook, source2, bookPart, rels, reserved);
   const states = workbook.sheets.map((sheet) => sheet.state);
   if (!states.includes("visible")) states[0] = "visible";
   let activeTab = Math.min(Math.max(0, workbook.activeSheet), workbook.sheets.length - 1);
@@ -19922,7 +20555,7 @@ async function saveXlsx(workbook) {
   const sourceXml = sourceBook ? source2?.text(sourceBook) : void 0;
   writer.add(
     bookPart,
-    workbookXml(workbook, sheetRefs, Math.max(0, activeTab), sourceXml),
+    workbookXml(workbook, sheetRefs, Math.max(0, activeTab), sourceXml, ctx.pivots.cachesXml),
     keptVba ? CONTENT_TYPES.workbookMacro : CONTENT_TYPES.workbook
   );
   writer.rels(bookPart, rels);
@@ -19965,6 +20598,7 @@ var init_save = __esm({
     init_doc_props();
     init_workbook_part2();
     init_worksheet2();
+    init_write();
     REGENERATED2 = /* @__PURE__ */ new Set([
       RELATIONSHIP_TYPES.worksheet,
       RELATIONSHIP_TYPES.chartsheet,
@@ -19975,7 +20609,8 @@ var init_save = __esm({
       RELATIONSHIP_TYPES.theme,
       RELATIONSHIP_TYPES.calcChain,
       RELATIONSHIP_TYPES.person,
-      RELATIONSHIP_TYPES.sheetMetadata
+      RELATIONSHIP_TYPES.sheetMetadata,
+      RELATIONSHIP_TYPES.pivotCacheDefinition
     ]);
     SHEET_TYPES = {
       [CONTENT_TYPES.chartsheet]: RELATIONSHIP_TYPES.chartsheet,
@@ -19995,7 +20630,7 @@ var write_exports = {};
 __export(write_exports, {
   saveXlsx: () => saveXlsx
 });
-var init_write = __esm({
+var init_write2 = __esm({
   "xlsx/write/index.ts"() {
     init_save();
   }
@@ -21510,7 +22145,7 @@ function createFileActions(context) {
       checkFileAbort(options?.signal);
       const [{ createWorkbook: createWorkbook2 }, { saveXlsx: saveXlsx2 }] = await Promise.all([
         Promise.resolve().then(() => (init_workbook(), workbook_exports)),
-        Promise.resolve().then(() => (init_write(), write_exports))
+        Promise.resolve().then(() => (init_write2(), write_exports))
       ]);
       checkFileAbort(options?.signal);
       const bytes = await withFileAbort(() => saveXlsx2(createWorkbook2()), options?.signal);