ooxml-core 1.8.4 → 1.10.0

package/dist/teams/index.cjs

@@ -288,9 +288,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 {
@@ -301,12 +301,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) {
@@ -940,19 +940,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) {
@@ -2618,10 +2618,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) {
@@ -2629,7 +2629,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;
@@ -2660,12 +2660,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)
   );
 }
@@ -2876,10 +2876,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),
@@ -2894,7 +2894,7 @@ function parseDisplayUnits(context, element2) {
     {
       builtInUnit: cVal(element2, "builtInUnit"),
       customUnit: cNumber(context, element2, "custUnit"),
-      label: label2,
+      label: label3,
       extLst: extensionList(element2)
     }
   );
@@ -15841,13 +15841,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(
@@ -17526,7 +17540,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 {
@@ -17570,7 +17584,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;
@@ -17998,6 +18012,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;
@@ -18495,9 +18514,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
     }));
   }
 });
@@ -18733,8 +18752,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;
@@ -18816,20 +18835,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,
@@ -19779,6 +19806,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;
@@ -19833,6 +19862,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) ?? "") !== "")
@@ -19918,6 +19948,904 @@ 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
+  ];
+  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(
+    (measure) => !measure || !pivot.fields.includes(measure.field) || !PIVOT_AGGREGATES.includes(measure.aggregate) || typeof measure.caption !== "string" || !measure.caption.trim() || measure.caption.length > 255 || pivot.fields.some((field) => field.toLowerCase() === measure.caption.toLowerCase())
+  ) || new Set(
+    [pivot.valueCaption, ...extras.map((measure) => measure.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.");
+}
+var PIVOT_AGGREGATES;
+var init_data = __esm({
+  "xlsx/pivot/data.ts"() {
+    init_model();
+    init_xml2();
+    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/measures.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 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((measure) => measure.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((measure) => `Total ${measure.caption}`)
+    ],
+    [
+      ...labels,
+      ...columns.flatMap(() => measures.map((measure) => measure.caption)),
+      ...measures.map(() => null)
+    ]
+  ];
+}
+var pivotMeasures, pivotMeasureNumber, pivotNumbers;
+var init_measures = __esm({
+  "xlsx/pivot/measures.ts"() {
+    init_model();
+    pivotMeasures = (pivot) => [
+      { field: pivot.valueField, aggregate: pivot.aggregate, caption: pivot.valueCaption },
+      ...pivot.additionalValues ?? []
+    ];
+    pivotMeasureNumber = (pivot, records, measure) => aggregate2(records, pivot.fields.indexOf(measure.field), measure.aggregate);
+    pivotNumbers = (pivot, records) => pivotMeasures(pivot).map((measure) => pivotMeasureNumber(pivot, records, measure));
+  }
+});
+
+// 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 compact = pivot.layout === "compact";
+  const tabular = !pivot.layout || pivot.layout === "tabular";
+  const blank = () => Array(width - rowLabels).fill(null);
+  pivotMeasures(pivot).forEach((measure, m) => {
+    const numbers3 = (keys, records) => [
+      ...columnItems.map(
+        (column) => pivotMeasureNumber(
+          pivot,
+          buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+          measure
+        )
+      ),
+      pivotMeasureNumber(pivot, records, measure)
+    ];
+    if (!tabular)
+      append([measure.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(
+          compact ? [pivotItemLabel(outer)] : [null, pivotItemLabel(outer), null],
+          top ? numbers3([key], group) : blank(),
+          { indices: [m, outerIndex], measure: m },
+          compact ? 1 : 0
+        );
+      const innerKeys = [...children2.get(key)].sort(
+        (a2, b) => innerIndices.get(a2) - innerIndices.get(b)
+      );
+      innerKeys.forEach((innerKey, child3) => {
+        const innerIndex = innerIndices.get(innerKey);
+        append(
+          compact ? [pivotItemLabel(secondRowItems[innerIndex])] : [
+            tabular && first2 ? measure.caption : null,
+            pivot.repeatLabels || tabular && child3 === 0 ? pivotItemLabel(outer) : null,
+            pivotItemLabel(secondRowItems[innerIndex])
+          ],
+          numbers3([key, innerKey], details.get(JSON.stringify([key, innerKey]))),
+          { indices: [m, outerIndex, innerIndex], measure: m },
+          compact ? 2 : 0
+        );
+        first2 = false;
+      });
+      if (bottom)
+        append(
+          compact ? [`${String(pivotItemLabel(outer))} Total`] : [null, `${String(pivotItemLabel(outer))} Total`, null],
+          numbers3([key], group),
+          { indices: [m, outerIndex], measure: m, type: "default" },
+          compact ? 1 : 0
+        );
+    });
+  });
+}
+var init_hierarchy_first = __esm({
+  "xlsx/pivot/hierarchy-first.ts"() {
+    init_data();
+    init_measures();
+  }
+});
+
+// xlsx/pivot/hierarchy.ts
+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 compact = 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 = compact ? 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 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 dimensions = pivotHeaderDimensions(pivot, columnItems.length, rowLabelColumns);
+  const rows = (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 (rows * dimensions.width > 1e6) throw new Error("The PivotTable result is too large.");
+  const labels = compact ? ["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, entry3, indent = 0) => {
+    values2.push([...labels2, ...numbers4]);
+    rowEntries.push(entry3);
+    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(
+      (measure, m) => append(
+        type ? [
+          `${type === "grand" ? "Total" : String(labels2[0])} ${measure.caption}`,
+          ...Array(rowLabelColumns - 1).fill(null)
+        ] : compact ? [measure.caption] : [
+          ...labels2.map(
+            (label3) => layout2 === "tabular" && m === 0 || pivot.repeatLabels ? label3 : null
+          ),
+          measure.caption
+        ],
+        values3.map((band) => band[m] ?? null),
+        { indices: type ? indices : [...indices, m], measure: m, ...type ? { type } : {} },
+        compact && !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(
+        (a2, b) => innerIndices.get(a2) - innerIndices.get(b)
+      );
+      if (between)
+        measures.forEach((measure, m) => {
+          if (layout2 !== "tabular")
+            append(
+              compact ? [measure.caption] : [pivot.repeatLabels ? label2(outer) : null, measure.caption, null],
+              Array(dimensions.width - rowLabelColumns).fill(null),
+              { indices: [outerIndex, m], measure: m },
+              compact ? 1 : 0
+            );
+          innerKeys.forEach((innerKey, child3) => {
+            const innerIndex = innerIndices.get(innerKey);
+            const keys = [key, innerKey];
+            const records = details.get(JSON.stringify(keys));
+            append(
+              compact ? [label2(secondRowItems[innerIndex])] : [
+                pivot.repeatLabels || layout2 === "tabular" && m === 0 && child3 === 0 ? label2(outer) : null,
+                layout2 === "tabular" && child3 === 0 ? measure.caption : null,
+                label2(secondRowItems[innerIndex])
+              ],
+              [
+                ...columnItems.map(
+                  (column) => pivotMeasureNumber(
+                    pivot,
+                    buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+                    measure
+                  )
+                ),
+                pivotMeasureNumber(pivot, records, measure)
+              ],
+              { indices: [outerIndex, m, innerIndex], measure: m },
+              compact ? 2 : 0
+            );
+          });
+        });
+      else
+        innerKeys.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;
+          if (rowsAxis) {
+            if (layout2 !== "tabular")
+              append(
+                compact ? [label2(inner)] : [pivot.repeatLabels ? label2(outer) : null, label2(inner), null],
+                Array(dimensions.width - rowLabelColumns).fill(null),
+                { indices: [outerIndex, innerIndex] },
+                compact ? 1 : 0
+              );
+            appendMeasures(
+              [pivot.repeatLabels || first2 ? label2(outer) : null, label2(inner)],
+              keys,
+              records,
+              [outerIndex, innerIndex]
+            );
+            first2 = false;
+            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) {
+        if (rowsAxis) {
+          appendMeasures([label2(outer)], [key], groups.get(key) ?? [], [outerIndex], "default");
+          return;
+        }
+        const caption = String(label2(outer));
+        append(
+          [`${caption} Total`, ...compact ? [] : [null]],
+          numbers3([key], groups.get(key) ?? []),
+          { indices: [outerIndex], type: "default" }
+        );
+      }
+    });
+  if (rowsAxis) appendMeasures([], [], pivot.records, [0], "grand");
+  else
+    append(["Grand Total", ...compact ? [] : [null]], numbers3([], pivot.records), {
+      indices: [0],
+      type: "grand"
+    });
+  return {
+    values: values2,
+    rowItems,
+    secondRowItems,
+    columnItems,
+    rowEntries,
+    firstDataRow,
+    rowLabelColumns,
+    indents,
+    ...rowsAxis ? { firstHeaderRow: 1 } : {}
+  };
+}
+var label2;
+var init_hierarchy2 = __esm({
+  "xlsx/pivot/hierarchy.ts"() {
+    init_data();
+    init_hierarchy_first();
+    init_measures();
+    label2 = pivotItemLabel;
+  }
+});
+
+// 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 compact = pivot.layout === "compact";
+  const headings = rowsAxis && pivot.layout !== void 0 && pivot.layout !== "tabular";
+  const dimensions = pivotHeaderDimensions(pivot, columnItems.length, rowsAxis && !compact ? 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 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 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((measure, m) => {
+        values2.push([
+          ...compact ? [grand ? `Total ${measure.caption}` : measure.caption] : [
+            grand ? `Total ${measure.caption}` : pivot.repeatLabels || !headings && m === 0 ? caption : null,
+            grand ? null : measure.caption
+          ],
+          ...bands.map((band) => band[m] ?? null)
+        ]);
+        indents.push(compact && !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, cells2.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: compact ? 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,
+          cells2.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 };
+}
+var init_aggregate = __esm({
+  "xlsx/pivot/aggregate.ts"() {
+    init_data();
+    init_hierarchy2();
+    init_measures();
+  }
+});
+
+// xlsx/pivot/values-axis.ts
+function pivotValueAxisItems(measures, columns) {
+  const entries = [];
+  if (columns === void 0) {
+    for (let measure = 0; measure < measures; measure++)
+      entries.push(
+        `<i${attrs({ i: measure || void 0 })}><x${attrs({ v: measure || void 0 })}/></i>`
+      );
+  } else {
+    for (let column = 0; column < columns; column++)
+      for (let measure = 0; measure < measures; measure++) {
+        entries.push(
+          `<i${attrs({ r: measure ? 1 : void 0, i: measure || void 0 })}>${measure ? "" : `<x${attrs({ v: column || void 0 })}/>`}<x${attrs({ v: measure || void 0 })}/></i>`
+        );
+      }
+    for (let measure = 0; measure < measures; measure++)
+      entries.push(`<i${attrs({ t: "grand", i: measure || void 0 })}><x/></i>`);
+  }
+  return `<colItems count="${entries.length}">${entries.join("")}</colItems>`;
+}
+var init_values_axis = __esm({
+  "xlsx/pivot/values-axis.ts"() {
+    init_xml_out();
+  }
+});
+
+// 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 measures = pivotMeasures(pivot);
+  const multiple = measures.length > 1;
+  const rowsAxis = pivot.valuesAxis === "rows";
+  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: measures.some((measure) => pivot.fields.indexOf(measure.field) === index2) ? 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.firstHeaderRow ?? (multiple && col >= 0 ? 1 : grid.firstDataRow - 1);
+  const rowIndices = rowsAxis && pivot.valuesPosition === "first" ? [-2, row2, second] : rowsAxis && pivot.valuesPosition === "between" ? [row2, -2, second] : [row2, ...second >= 0 ? [second] : [], ...rowsAxis ? [-2] : []];
+  let previous = [];
+  const rowItems = grid.rowEntries?.map((entry3) => {
+    let prefix = 0;
+    if (entry3.type === "default" && rowsAxis && pivot.valuesPosition === "first") prefix = 1;
+    else if (!entry3.type)
+      while (prefix < entry3.indices.length - 1 && entry3.indices[prefix] === previous[prefix])
+        prefix++;
+    previous = entry3.type && !(entry3.type === "default" && pivot.valuesPosition === "first") ? [] : entry3.indices;
+    return `<i${attrs({ t: entry3.type, r: prefix || void 0, i: entry3.measure || 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 (multiple && !rowsAxis)
+    body += `<colFields count="${col >= 0 ? 2 : 1}">${col >= 0 ? `<field x="${col}"/>` : ""}<field x="-2"/></colFields>${pivotValueAxisItems(measures.length, col >= 0 ? grid.columnItems.length : void 0)}`;
+  else if (col >= 0)
+    body += `<colFields count="1"><field x="${col}"/></colFields><colItems count="${grid.columnItems.length + 1}">${items(grid.columnItems.length)}</colItems>`;
+  else
+    body += rowsAxis ? '<colItems count="1"><i/></colItems>' : '<colItems count="1"><i><x/></i></colItems>';
+  body += `<dataFields count="${measures.length}">${measures.map((measure) => `<dataField${attrs({ name: encodeEscapes(measure.caption), fld: pivot.fields.indexOf(measure.field), subtotal: measure.aggregate, baseField: 0, baseItem: 0 })}/>`).join("")}</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("dataOnRows", rowsAxis ? "1" : "0");
+  if (rowsAxis && (pivot.valuesPosition === "between" || pivot.valuesPosition === "first"))
+    root.setAttribute("dataPosition", pivot.valuesPosition === "first" ? "0" : "1");
+  else root.removeAttribute("dataPosition");
+  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");
+  if (multiple && !elements(first(root, "extLst", NS.x) ?? parseXml("<root/>").documentElement).some(
+    (extension) => first(
+      extension,
+      "pivotTableDefinition",
+      "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
+    )
+  )) {
+    let list = first(root, "extLst", NS.x);
+    if (!list) {
+      list = doc.createElementNS(NS.x, "extLst");
+      root.appendChild(list);
+    }
+    const extension = parseXml(
+      `<ext xmlns="${NS.x}" uri="{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}"><x14:pivotTableDefinition xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" hideValuesRow="1"/></ext>`
+    ).documentElement;
+    list.appendChild(doc.importNode(extension, true));
+  }
+  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 (multiple && definition) definition.setAttribute("hideValuesRow", "1");
+    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();
+    init_measures();
+    init_values_axis();
+  }
+});
+
+// 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");
@@ -19960,6 +20888,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);
@@ -20025,7 +20954,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);
@@ -20068,6 +20997,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,
@@ -20078,7 +21008,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,
@@ -20098,7 +21029,7 @@ var write_exports = {};
 __export(write_exports, {
   saveXlsx: () => saveXlsx
 });
-var init_write = __esm({
+var init_write2 = __esm({
   "xlsx/write/index.ts"() {
     init_save();
   }
@@ -21613,7 +22544,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);