ooxml-core 1.9.0 → 1.11.0

package/dist/xlsx/load/index.cjs

@@ -1009,7 +1009,7 @@ function i(x, y, z) {
 }
 var T = Array.from(
   { length: 64 },
-  (_, index2) => Math.floor(Math.abs(Math.sin(index2 + 1)) * 2 ** 32)
+  (_, index3) => Math.floor(Math.abs(Math.sin(index3 + 1)) * 2 ** 32)
 );
 var SHIFTS = [
   [7, 12, 17, 22],
@@ -2537,7 +2537,7 @@ function toArrayBuffer(bytes) {
 }
 function isCompoundFile(input) {
   const bytes = toBytes(input);
-  return bytes.length >= 8 && OLE_MAGIC2.every((value2, index2) => bytes[index2] === value2);
+  return bytes.length >= 8 && OLE_MAGIC2.every((value2, index3) => bytes[index3] === value2);
 }
 function openEncryptedPackage(input) {
   const bytes = toBytes(input);
@@ -3718,7 +3718,7 @@ var PartPatch = class {
     const { root, children: children2 } = scan(xml);
     const kids2 = elements(rootElement);
     if (kids2.length !== children2.length) throw new Error("Property part markup is not supported");
-    kids2.forEach((kid, index2) => this.spans.set(kid, children2[index2]));
+    kids2.forEach((kid, index3) => this.spans.set(kid, children2[index3]));
     this.root = root;
     for (const attribute2 of Array.from(rootElement.attributes)) {
       if (attribute2.name === "xmlns") this.defaultNs = attribute2.value;
@@ -3968,7 +3968,7 @@ function writeAppProperties(props, sourceXml) {
   const patch = new PartPatch(xml, root);
   const prior = readKnown(root, ns);
   const ownPrefix = root.prefix ? `${root.prefix}:` : "";
-  FIELDS2.forEach(([field, local, kind], index2) => {
+  FIELDS2.forEach(([field, local, kind], index3) => {
     const value2 = props[field];
     const existing = first(root, local, ns.app);
     if (value2 === void 0 || kind === "text" && value2 === "") {
@@ -3982,7 +3982,7 @@ function writeAppProperties(props, sourceXml) {
       patch.setContent(existing, body);
       return;
     }
-    const next = FIELDS2.slice(index2 + 1).map(([, name]) => first(root, name, ns.app)).find((node) => node !== void 0);
+    const next = FIELDS2.slice(index3 + 1).map(([, name]) => first(root, name, ns.app)).find((node) => node !== void 0);
     patch.insert(`<${ownPrefix}${local}>${body}</${ownPrefix}${local}>`, next);
   });
   return patch.toString();
@@ -4077,9 +4077,9 @@ function writeCustomProperties(properties2) {
   });
   if (!unique2.length) return void 0;
   const pids = allocateCustomPropertyIds(unique2);
-  const body = unique2.map((property, index2) => {
+  const body = unique2.map((property, index3) => {
     const link = property.linkTarget ? ` linkTarget="${escape(property.linkTarget, true)}"` : "";
-    return `<property fmtid="${CUSTOM_PROPERTIES_FMTID}" pid="${pids[index2] ?? index2 + 2}" name="${escape(property.name, true)}"${link}>${variantXml(property)}</property>`;
+    return `<property fmtid="${CUSTOM_PROPERTIES_FMTID}" pid="${pids[index3] ?? index3 + 2}" name="${escape(property.name, true)}"${link}>${variantXml(property)}</property>`;
   }).join("");
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Properties xmlns="${NS.customProperties}" xmlns:vt="${NS.vt}">${body}</Properties>`;
@@ -5304,10 +5304,10 @@ var MONTH_NAMES = [
 function monthFromName(name) {
   const lower2 = name.toLowerCase();
   if (lower2.length < 3) return void 0;
-  const index2 = MONTH_NAMES.findIndex(
+  const index3 = MONTH_NAMES.findIndex(
     (m) => m.startsWith(lower2) || lower2.length > 3 && lower2 === m
   );
-  return index2 < 0 ? void 0 : index2 + 1;
+  return index3 < 0 ? void 0 : index3 + 1;
 }
 function fullYear(text) {
   const y = Number(text);
@@ -5534,10 +5534,10 @@ function internStyle(workbook, style2) {
   const known = cache2.get(key);
   if (known !== void 0 && workbook.styles[known] && styleKey(workbook.styles[known]) === key)
     return known;
-  const index2 = workbook.styles.findIndex((candidate) => styleKey(candidate) === key);
-  if (index2 >= 0) {
-    cache2.set(key, index2);
-    return index2;
+  const index3 = workbook.styles.findIndex((candidate) => styleKey(candidate) === key);
+  if (index3 >= 0) {
+    cache2.set(key, index3);
+    return index3;
   }
   workbook.styles.push(style2);
   cache2.set(key, workbook.styles.length - 1);
@@ -5644,7 +5644,7 @@ function createWorksheet(name, sheetId) {
 function createWorkbook(options = {}) {
   const names = options.sheets?.length ? options.sheets : ["Sheet1"];
   return {
-    sheets: names.map((name, index2) => createWorksheet(name, index2 + 1)),
+    sheets: names.map((name, index3) => createWorksheet(name, index3 + 1)),
     styles: [defaultCellStyle()],
     namedStyles: [{ name: "Normal", style: defaultCellStyle(), builtinId: 0 }],
     definedNames: [],
@@ -6419,9 +6419,99 @@ function sparklineDataRange(workbook, sheet, source2) {
   }
   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 }) };
+  const index3 = ast.prefix ? workbook.sheets.findIndex((ws) => ws.name.toLowerCase() === ast.prefix.sheet.toLowerCase()) : sheet;
+  if (!workbook.sheets[index3]) throw new Error("The reference is not valid.");
+  return { sheet: index3, range: checkedSparklineRange({ start: ast.ref.start, end: ast.ref.end }) };
+}
+
+// xlsx/pivot/page-filter.ts
+function validatePivotPageFilter(pivot) {
+  const filter2 = pivot.pageFilter;
+  const extras = Array.isArray(pivot.additionalValues) ? pivot.additionalValues : [];
+  if (filter2 === void 0) return;
+  if (!filter2 || typeof filter2 !== "object" || Array.isArray(filter2) || Object.keys(filter2).some((key) => key !== "field" && key !== "item") || typeof filter2.field !== "string" || !pivot.fields.includes(filter2.field) || [
+    pivot.rowField,
+    pivot.secondRowField,
+    pivot.columnField,
+    pivot.valueField,
+    ...extras.map((v) => v?.field)
+  ].includes(filter2.field) || pivot.valuesAxis === "rows")
+    throw new Error("Report filters require Values on columns and a separate source field.");
+  if (filter2.item !== void 0 && !(filter2.item === null || typeof filter2.item === "string" || typeof filter2.item === "boolean" || typeof filter2.item === "number" && Number.isFinite(filter2.item) || isCellError(filter2.item) && isErrorCode(filter2.item.error) && Object.keys(filter2.item).length === 1))
+    throw new Error("Choose a cached literal report filter item.");
+}
+function pivotPageProjection(pivot) {
+  const filter2 = pivot.pageFilter;
+  if (!filter2) return pivot;
+  const labels = /* @__PURE__ */ new Map();
+  for (const item of pivotItems(pivot, filter2.field)) {
+    const label3 = String(pivotItemLabel(item)).toLowerCase(), key2 = pivotValueKey(item);
+    if (label3 === "(all)" || labels.has(label3) && labels.get(label3) !== key2)
+      throw new Error("Ambiguous report filter item captions are preserved.");
+    labels.set(label3, key2);
+  }
+  if (filter2.item === void 0) return pivot;
+  const index3 = pivot.fields.indexOf(filter2.field), key = pivotValueKey(filter2.item);
+  const records = pivot.records.filter((record) => pivotValueKey(record[index3] ?? null) === key);
+  if (!records.length) throw new Error("The report filter item is missing from the source.");
+  if (JSON.stringify(records[0][index3] ?? null) !== JSON.stringify(filter2.item))
+    throw new Error("Choose an exact cached literal report filter item.");
+  return { ...pivot, records };
+}
+function prependPivotPage(grid, pivot) {
+  if (!pivot.pageFilter) return grid;
+  const width = grid.values[0].length;
+  return {
+    ...grid,
+    values: [
+      [
+        pivot.pageFilter.field,
+        pivot.pageFilter.item === void 0 ? "(All)" : pivotItemLabel(pivot.pageFilter.item),
+        ...Array(width - 2).fill(null)
+      ],
+      Array(width).fill(null),
+      ...grid.values
+    ],
+    firstDataRow: grid.firstDataRow + 2,
+    ...grid.firstHeaderRow !== void 0 ? { firstHeaderRow: grid.firstHeaderRow + 2 } : {},
+    ...grid.indents ? { indents: [0, 0, ...grid.indents] } : {}
+  };
+}
+var index = (raw2) => raw2 !== null && /^\d+$/.test(raw2.trim()) && Number.isSafeInteger(Number(raw2)) ? Number(raw2) : NaN;
+function readPivotPageFilter(root, fields, shared) {
+  const list = first(root, "pageFields", NS.x), location = first(root, "location", NS.x);
+  const definitions = children(first(root, "pivotFields", NS.x), "pivotField", NS.x);
+  if (!list) {
+    if (definitions.some((n) => n.getAttribute("axis") === "axisPage") || location?.hasAttribute("rowPageCount") || location?.hasAttribute("colPageCount"))
+      throw new Error("Unmodeled report filter metadata");
+    return;
+  }
+  if (root.getAttribute("multipleFieldFilters") === "1")
+    throw new Error("Multiple report filters are preserved");
+  const pages = children(list, "pageField", NS.x);
+  if (pages.length !== 1 || list.getAttribute("count") !== "1" || location?.getAttribute("rowPageCount") !== "1" || location.getAttribute("colPageCount") !== "1")
+    throw new Error("Only one report filter is modeled");
+  const page = pages[0], field = index(page.getAttribute("fld"));
+  if (page.getAttribute("hier") !== "-1" || !fields[field] || definitions[field]?.getAttribute("axis") !== "axisPage" || definitions.filter((n) => n.getAttribute("axis") === "axisPage").length !== 1)
+    throw new Error("Unsupported report field");
+  const container2 = first(definitions[field], "items", NS.x);
+  const items = children(container2, "item", NS.x);
+  if (!container2 || index(container2.getAttribute("count")) !== items.length || items.filter((n) => n.getAttribute("t") === "default").length !== 1 || items.at(-1)?.getAttribute("t") !== "default" || items.at(-1)?.hasAttribute("x"))
+    throw new Error("Unsupported report field items");
+  const data = items.slice(0, -1).map((item2) => {
+    const i2 = index(item2.getAttribute("x"));
+    if (item2.hasAttribute("t") || !Number.isInteger(i2) || i2 >= shared[field].length)
+      throw new Error("Invalid report cache item");
+    return i2;
+  });
+  if (new Set(data).size !== data.length || data.length !== shared[field].length)
+    throw new Error("Incomplete report cache items");
+  const item = page.getAttribute("item");
+  if (item === null) return { field: fields[field] };
+  const selected2 = index(item);
+  if (!Number.isInteger(selected2) || selected2 >= data.length)
+    throw new Error("Invalid report item selection");
+  return { field: fields[field], item: shared[field][data[selected2]] };
 }
 
 // xlsx/pivot/data.ts
@@ -6430,10 +6520,10 @@ function pivotValueKey(value2) {
   return value2 === null || value2 === "" ? "blank" : isCellError(value2) ? `error:${value2.error}` : `${typeof value2}:${String(value2).toLowerCase()}`;
 }
 function pivotItems(pivot, field) {
-  const index2 = pivot.fields.indexOf(field);
+  const index3 = pivot.fields.indexOf(field);
   const items = /* @__PURE__ */ new Map();
   for (const record of pivot.records) {
-    const value2 = record[index2] ?? null;
+    const value2 = record[index3] ?? null;
     const key = pivotValueKey(value2);
     if (!items.has(key)) items.set(key, value2);
   }
@@ -6451,35 +6541,209 @@ function pivotItemLabel(value2) {
   return isCellError(value2) ? value2.error : value2;
 }
 function validatePivotFields(pivot) {
+  validatePivotPageFilter(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.");
 }
 
+// xlsx/pivot/measures.ts
+var pivotMeasures = (pivot) => [
+  { field: pivot.valueField, aggregate: pivot.aggregate, caption: pivot.valueCaption },
+  ...pivot.additionalValues ?? []
+];
+function aggregate(records, field, type) {
+  if (!records.length) return null;
+  const values2 = records.map((record) => record[field] ?? null);
+  if (type === "count") return values2.filter((value2) => value2 !== null && value2 !== "").length;
+  const error = values2.find(isCellError);
+  if (error) return error;
+  const numbers3 = values2.filter((value2) => typeof value2 === "number");
+  if (!numbers3.length) return type === "average" ? { error: "#DIV/0!" } : 0;
+  if (type === "min") return numbers3.reduce((a2, b) => Math.min(a2, b));
+  if (type === "max") return numbers3.reduce((a2, b) => Math.max(a2, b));
+  const sum2 = numbers3.reduce((total2, value2) => total2 + value2, 0);
+  return type === "average" ? sum2 / numbers3.length : sum2;
+}
+var pivotMeasureNumber = (pivot, records, measure) => aggregate(records, pivot.fields.indexOf(measure.field), measure.aggregate);
+var pivotNumbers = (pivot, records) => pivotMeasures(pivot).map((measure) => pivotMeasureNumber(pivot, records, measure));
+function pivotHeaderDimensions(pivot, columnItems, rowLabels) {
+  const measures = 1 + (pivot.additionalValues?.length ?? 0);
+  if (pivot.valuesAxis === "rows")
+    return {
+      rows: (pivot.columnField ? 2 : 1) + (pivot.pageFilter ? 2 : 0),
+      width: rowLabels + (pivot.columnField ? columnItems + 1 : 1)
+    };
+  return {
+    rows: (pivot.columnField ? measures > 1 ? 3 : 2 : 1) + (pivot.pageFilter ? 2 : 0),
+    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)
+    ]
+  ];
+}
+
+// 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, child4) => {
+        const innerIndex = innerIndices.get(innerKey);
+        append(
+          compact ? [pivotItemLabel(secondRowItems[innerIndex])] : [
+            tabular && first2 ? measure.caption : null,
+            pivot.repeatLabels || tabular && child4 === 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
+        );
+    });
+  });
+}
+
 // xlsx/pivot/hierarchy.ts
 var label = pivotItemLabel;
-function hierarchicalPivotGrid(pivot, aggregate3) {
+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 valueField = pivot.fields.indexOf(pivot.valueField);
   const layout3 = pivot.layout ?? "tabular";
   const compact = layout3 === "compact";
-  const top = layout3 !== "tabular" && pivot.subtotals !== false && (pivot.subtotalPosition ?? "top") === "top";
+  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) && layout3 !== "tabular" && pivot.subtotals !== false && (pivot.subtotalPosition ?? "top") === "top";
   const bottom = pivot.subtotals !== false && !top;
-  const rowLabelColumns = compact ? 1 : 2;
+  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 innerIndices = new Map(secondRowItems.map((item, index3) => [pivotValueKey(item), index3]));
   const buckets = /* @__PURE__ */ new Map();
   const collect = (map, key, record) => {
     const list = map.get(key);
@@ -6499,20 +6763,12 @@ function hierarchicalPivotGrid(pivot, aggregate3) {
         collect(buckets, JSON.stringify([...key, column]), record);
     }
   }
-  const rows = details.size + rowItems.length * (Number(layout3 !== "tabular") + Number(bottom)) + 3;
-  if (rows * (columnItems.length + 3) > 1e6)
-    throw new Error("The PivotTable result is too large.");
+  const dimensions = pivotHeaderDimensions(pivot, columnItems.length, rowLabelColumns);
+  const rows = (details.size + rowItems.length * Number(bottom) + 1) * (rowsAxis ? measures.length : 1) + rowItems.length * Number(layout3 !== "tabular") * (firstValues ? measures.length : 1) + (firstValues ? measures.length : between ? rowItems.length * measures.length : details.size) * Number(rowsAxis && layout3 !== "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 = pivot.columnField ? [
-    [
-      pivot.valueCaption,
-      ...compact ? [] : [null],
-      compact ? "Column Labels" : pivot.columnField,
-      ...columnItems.slice(1).map(() => null),
-      null
-    ],
-    [...labels, ...columnItems.map(label), "Grand Total"]
-  ] : [[...labels, pivot.valueCaption]];
+  const values2 = pivotHeaders(pivot, columnItems, labels, label);
+  const firstDataRow = values2.length;
   const indents = values2.map(() => 0);
   const rowEntries = [];
   const append = (labels2, numbers4, entry3, indent = 0) => {
@@ -6520,91 +6776,187 @@ function hierarchicalPivotGrid(pivot, aggregate3) {
     rowEntries.push(entry3);
     indents.push(indent);
   };
-  const numbers3 = (keys, records) => [
+  const bands = (keys, records) => [
     ...columnItems.map(
-      (column) => aggregate3(
-        buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
-        valueField,
-        pivot.aggregate
-      )
+      (column) => pivotNumbers(pivot, buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [])
     ),
-    aggregate3(records, valueField, pivot.aggregate)
+    pivotNumbers(pivot, records)
   ];
-  rowItems.forEach((outer, outerIndex) => {
-    const key = pivotValueKey(outer);
-    if (layout3 !== "tabular")
-      append(
-        [label(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 ? [label(inner)] : [
-          pivot.repeatLabels || layout3 === "tabular" && first2 ? label(outer) : null,
-          label(inner)
+  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) => layout3 === "tabular" && m === 0 || pivot.repeatLabels ? label3 : null
+          ),
+          measure.caption
         ],
-        numbers3(keys, records),
-        { indices: [outerIndex, innerIndex] },
-        compact ? 1 : 0
-      );
-      first2 = false;
+        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
     });
-    if (bottom) {
-      const caption = String(label(outer));
-      append(
-        [`${caption} Total`, ...compact ? [] : [null]],
-        numbers3([key], groups.get(key) ?? []),
-        { indices: [outerIndex], type: "default" }
+  else
+    rowItems.forEach((outer, outerIndex) => {
+      const key = pivotValueKey(outer);
+      if (layout3 !== "tabular")
+        append(
+          [label(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)
       );
-    }
-  });
-  append(["Grand Total", ...compact ? [] : [null]], numbers3([], pivot.records), {
-    indices: [0],
-    type: "grand"
-  });
+      if (between)
+        measures.forEach((measure, m) => {
+          if (layout3 !== "tabular")
+            append(
+              compact ? [measure.caption] : [pivot.repeatLabels ? label(outer) : null, measure.caption, null],
+              Array(dimensions.width - rowLabelColumns).fill(null),
+              { indices: [outerIndex, m], measure: m },
+              compact ? 1 : 0
+            );
+          innerKeys.forEach((innerKey, child4) => {
+            const innerIndex = innerIndices.get(innerKey);
+            const keys = [key, innerKey];
+            const records = details.get(JSON.stringify(keys));
+            append(
+              compact ? [label(secondRowItems[innerIndex])] : [
+                pivot.repeatLabels || layout3 === "tabular" && m === 0 && child4 === 0 ? label(outer) : null,
+                layout3 === "tabular" && child4 === 0 ? measure.caption : null,
+                label(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 (layout3 !== "tabular")
+              append(
+                compact ? [label(inner)] : [pivot.repeatLabels ? label(outer) : null, label(inner), null],
+                Array(dimensions.width - rowLabelColumns).fill(null),
+                { indices: [outerIndex, innerIndex] },
+                compact ? 1 : 0
+              );
+            appendMeasures(
+              [pivot.repeatLabels || first2 ? label(outer) : null, label(inner)],
+              keys,
+              records,
+              [outerIndex, innerIndex]
+            );
+            first2 = false;
+            return;
+          }
+          append(
+            compact ? [label(inner)] : [
+              pivot.repeatLabels || layout3 === "tabular" && first2 ? label(outer) : null,
+              label(inner)
+            ],
+            numbers3(keys, records),
+            { indices: [outerIndex, innerIndex] },
+            compact ? 1 : 0
+          );
+          first2 = false;
+        });
+      if (bottom) {
+        if (rowsAxis) {
+          appendMeasures([label(outer)], [key], groups.get(key) ?? [], [outerIndex], "default");
+          return;
+        }
+        const caption = String(label(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: pivot.columnField ? 2 : 1,
+    firstDataRow,
     rowLabelColumns,
-    indents
+    indents,
+    ...rowsAxis ? { firstHeaderRow: 1 } : {}
   };
 }
 
 // xlsx/pivot/aggregate.ts
-function aggregate(records, field, type) {
-  if (!records.length) return null;
-  const values2 = records.map((record) => record[field] ?? null);
-  if (type === "count") return values2.filter((value2) => value2 !== null && value2 !== "").length;
-  const error = values2.find(isCellError);
-  if (error) return error;
-  const numbers3 = values2.filter((value2) => typeof value2 === "number");
-  if (!numbers3.length) return type === "average" ? { error: "#DIV/0!" } : 0;
-  if (type === "min") return numbers3.reduce((a2, b) => Math.min(a2, b));
-  if (type === "max") return numbers3.reduce((a2, b) => Math.max(a2, b));
-  const sum2 = numbers3.reduce((total2, value2) => total2 + value2, 0);
-  return type === "average" ? sum2 / numbers3.length : sum2;
-}
 function pivotGrid(pivot) {
   validatePivotFields(pivot);
-  if (pivot.secondRowField) return hierarchicalPivotGrid(pivot, aggregate);
+  return prependPivotPage(pivotDataGrid(pivotPageProjection(pivot)), pivot);
+}
+function pivotDataGrid(pivot) {
+  if (pivot.secondRowField) return hierarchicalPivotGrid(pivot);
   const rowItems = pivotItems(pivot, pivot.rowField);
   const columnItems = pivot.columnField ? pivotItems(pivot, pivot.columnField) : [];
-  if ((rowItems.length + 3) * (columnItems.length + 2) > 1e6)
+  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 valueField = pivot.fields.indexOf(pivot.valueField);
   const groups = /* @__PURE__ */ new Map();
   const cells = /* @__PURE__ */ new Map();
   const columns = /* @__PURE__ */ new Map();
@@ -6622,50 +6974,95 @@ function pivotGrid(pivot) {
       collect(cells, JSON.stringify([key, col]), record);
     }
   }
-  const label3 = pivotItemLabel;
-  const values2 = pivot.columnField ? [
-    [
-      pivot.valueCaption,
-      pivot.layout === "compact" ? "Column Labels" : pivot.columnField,
-      ...columnItems.slice(1).map(() => null),
-      null
-    ],
-    [
-      pivot.layout === "compact" ? "Row Labels" : pivot.rowField,
-      ...columnItems.map(label3),
-      "Grand Total"
-    ]
-  ] : [[pivot.layout === "compact" ? "Row Labels" : pivot.rowField, pivot.valueCaption]];
+  const firstDataRow = values2.length;
+  if (rowsAxis) {
+    const measures = pivotMeasures(pivot);
+    const rowEntries = [];
+    const indents = values2.map(() => 0);
+    const append = (caption, bands, index3, 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] : [index3, m],
+          measure: m,
+          ...grand ? { type: "grand" } : {}
+        });
+      });
+    };
+    rowItems.forEach((item, index3) => {
+      const key = pivotValueKey(item);
+      if (headings) {
+        values2.push([label3(item), ...Array(dimensions.width - 1).fill(null)]);
+        rowEntries.push({ indices: [index3] });
+        indents.push(0);
+      }
+      append(
+        label3(item),
+        [
+          ...columnItems.map(
+            (col) => pivotNumbers(pivot, cells.get(JSON.stringify([key, pivotValueKey(col)])) ?? [])
+          ),
+          pivotNumbers(pivot, groups.get(key) ?? [])
+        ],
+        index3
+      );
+    });
+    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.map(
-        (col) => aggregate(
-          cells.get(JSON.stringify([pivotValueKey(row2), pivotValueKey(col)])) ?? [],
-          valueField,
-          pivot.aggregate
+      ...columnItems.flatMap(
+        (col) => pivotNumbers(
+          pivot,
+          cells.get(JSON.stringify([pivotValueKey(row2), pivotValueKey(col)])) ?? []
         )
       ),
-      aggregate(records, valueField, pivot.aggregate)
+      ...pivotNumbers(pivot, records)
     ]);
   }
   values2.push([
     "Grand Total",
-    ...columnItems.map(
-      (col) => aggregate(columns.get(pivotValueKey(col)) ?? [], valueField, pivot.aggregate)
-    ),
-    aggregate(pivot.records, valueField, pivot.aggregate)
+    ...columnItems.flatMap((col) => pivotNumbers(pivot, columns.get(pivotValueKey(col)) ?? [])),
+    ...pivotNumbers(pivot, pivot.records)
   ]);
-  return { values: values2, rowItems, columnItems, firstDataRow: pivot.columnField ? 2 : 1 };
+  return { values: values2, rowItems, columnItems, firstDataRow };
 }
 
 // xlsx/pivot/admission.ts
 var X14 = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main";
 var LAYOUT = "http://schemas.microsoft.com/office/spreadsheetml/2016/pivotdefaultlayout";
 var TABLE = {
-  pivotTableDefinition: "name cacheId dataCaption updatedVersion minRefreshableVersion createdVersion applyNumberFormats applyBorderFormats applyFontFormats applyPatternFormats applyAlignmentFormats applyWidthHeightFormats useAutoFormatting itemPrintTitles indent compact compactData outline outlineData multipleFieldFilters rowGrandTotals colGrandTotals",
-  location: "ref firstHeaderRow firstDataRow firstDataCol",
+  pivotTableDefinition: "name cacheId dataCaption dataOnRows dataPosition updatedVersion minRefreshableVersion createdVersion applyNumberFormats applyBorderFormats applyFontFormats applyPatternFormats applyAlignmentFormats applyWidthHeightFormats useAutoFormatting itemPrintTitles indent compact compactData outline outlineData multipleFieldFilters rowGrandTotals colGrandTotals",
+  location: "ref firstHeaderRow firstDataRow firstDataCol rowPageCount colPageCount",
+  pageFields: "count",
+  pageField: "fld item hier",
   pivotFields: "count",
   pivotField: "axis dataField compact outline showAll subtotalTop defaultSubtotal",
   items: "count",
@@ -6675,7 +7072,7 @@ var TABLE = {
   field: "x",
   rowItems: "count",
   colItems: "count",
-  i: "t r",
+  i: "t r i",
   x: "v",
   dataFields: "count",
   dataField: "name fld subtotal baseField baseItem showDataAs",
@@ -6706,7 +7103,7 @@ function inspect(node, profile, cache2) {
     for (let i2 = 0; i2 < node.attributes.length; i2++) {
       const attr2 = node.attributes.item(i2);
       if (attr2.name.startsWith("xmlns")) continue;
-      if (!cache2 && node.namespaceURI === X14 && node.localName === "pivotTableDefinition" && attr2.name === "hideValuesRow" && attr2.value === "1")
+      if (!cache2 && node.namespaceURI === X14 && node.localName === "pivotTableDefinition" && attr2.name === "hideValuesRow" && ["0", "1"].includes(attr2.value))
         continue;
       if (!cache2 && node.namespaceURI === X14 && (node.localName === "pivotField" && attr2.name === "fillDownLabels" || node.localName === "pivotTableDefinition" && attr2.name === "fillDownLabelsDefault") && ["0", "1"].includes(attr2.value))
         continue;
@@ -6735,7 +7132,9 @@ function inspect(node, profile, cache2) {
       throw new Error("Unsupported PivotTable option");
     if (attr2.localName === "numFmtId" && attr2.value !== "0")
       throw new Error("Unsupported PivotTable field number format");
-    if (node.localName === "pivotTableDefinition" && ["compact", "compactData", "outline", "outlineData"].includes(attr2.localName) && !["0", "1"].includes(attr2.value))
+    if (node.localName === "pivotTableDefinition" && ["compact", "compactData", "outline", "outlineData", "dataOnRows"].includes(
+      attr2.localName
+    ) && !["0", "1"].includes(attr2.value))
       throw new Error("Unsupported PivotTable global layout");
     if (node.localName === "item" && attr2.localName === "t" && !["default", "data"].includes(attr2.value))
       throw new Error("Unsupported PivotTable subtotal");
@@ -6758,6 +7157,258 @@ function assertPivotRecords(records) {
   );
 }
 
+// xlsx/write/xml-out.ts
+var XML_HEADER = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+var CONTROL = "\0-\b\v\f-" + String.fromCharCode(65534, 65535);
+var NEEDS_ESCAPE = new RegExp(`[${CONTROL}\r]|_x[0-9A-Fa-f]{4}_`);
+var ESCAPABLE = new RegExp(`[${CONTROL}\r]|_(?=x[0-9A-Fa-f]{4}_)`, "g");
+function encodeEscapes(text) {
+  if (!NEEDS_ESCAPE.test(text)) return text;
+  return text.replace(
+    ESCAPABLE,
+    (ch) => `_x${ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}_`
+  );
+}
+var INVALID_XML = new RegExp(`[${CONTROL}]`, "g");
+var escapeText2 = (text) => text.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escapeAttr3 = (text) => text.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;").replace(/\t/g, "&#9;");
+function attrs(values2) {
+  let out = "";
+  for (const [name, value2] of Object.entries(values2)) {
+    if (value2 === void 0) continue;
+    const text = typeof value2 === "boolean" ? value2 ? "1" : "0" : typeof value2 === "number" ? num(value2) : value2;
+    out += ` ${name}="${escapeAttr3(text)}"`;
+  }
+  return out;
+}
+var el = (name, values2 = {}, content2 = "") => content2 ? `<${name}${attrs(values2)}>${content2}</${name}>` : `<${name}${attrs(values2)}/>`;
+var num = (value2) => Object.is(value2, -0) ? "0" : String(value2);
+function tElement(text, name = "t") {
+  const encoded = escapeText2(encodeEscapes(text));
+  const preserve = /^\s|\s$|\n|\t/.test(text) ? ' xml:space="preserve"' : "";
+  return `<${name}${preserve}>${encoded}</${name}>`;
+}
+var MAIN_NS = ' xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"';
+function inlineFragment(xml) {
+  const end = xml.indexOf(">");
+  if (end < 0) return xml;
+  const head = xml.slice(0, end);
+  return head.includes(MAIN_NS) ? head.replace(MAIN_NS, "") + xml.slice(end) : xml;
+}
+
+// xlsx/pivot/values-axis.ts
+function remapPivotRowEntries(entries, axes2) {
+  return entries.map(
+    (entry3) => entry3.type === "grand" ? entry3 : {
+      ...entry3,
+      indices: entry3.indices.map((item, axis) => {
+        const index3 = axes2[axis]?.[item];
+        if (index3 === void 0) throw new Error("Invalid report row axis item");
+        return index3;
+      })
+    }
+  );
+}
+function pivotFieldIndex(field) {
+  const raw2 = field?.getAttribute("x");
+  if (raw2 === null || raw2 === void 0 || !/^-?\d+$/.test(raw2.trim())) return NaN;
+  const value2 = Number(raw2);
+  return Number.isSafeInteger(value2) ? value2 : NaN;
+}
+function pivotValueIndex(root, axis) {
+  const index3 = axis.findIndex((field) => pivotFieldIndex(field) === -2);
+  const position = root.getAttribute("dataPosition");
+  if (position !== null && (!/^\d+$/.test(position.trim()) || Number(position) !== index3))
+    throw new Error("Inconsistent Values axis position");
+  if (axis.length === 3 && index3 < 2 && position === null)
+    throw new Error("Missing leading or between-field Values position");
+  return index3;
+}
+function pivotValueAxisItems(measures, columns, columnIndices) {
+  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: (columnIndices?.[column] ?? 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>`;
+}
+function supportedPivotAxes(rows, columns, measures, valuesOnRows) {
+  const index3 = pivotFieldIndex;
+  if (valuesOnRows)
+    return measures > 1 && (rows.length === 2 || rows.length === 3) && (index3(rows[0]) >= 0 || rows.length === 3) && rows.filter((field) => index3(field) === -2).length === 1 && rows.filter((field) => index3(field) !== -2).every((field) => index3(field) >= 0) && columns.length <= 1 && (!columns.length || index3(columns[0]) >= 0);
+  if (rows.some((field) => !Number.isInteger(index3(field)) || index3(field) < 0)) return false;
+  return measures === 1 ? columns.length <= 1 : columns.length >= 1 && columns.length <= 2 && index3(columns.at(-1)) === -2 && (columns.length !== 2 || index3(columns[0]) >= 0);
+}
+
+// drawingml/dom.ts
+function attributeReader(element2) {
+  return (name) => {
+    if (!element2) return void 0;
+    const direct = element2.getAttribute(name);
+    if (direct !== null) return direct;
+    const attributes = element2.attributes;
+    for (let index3 = 0; index3 < attributes.length; index3++) {
+      const candidate = attributes.item(index3);
+      if (candidate && candidate.localName === name) return candidate.value;
+    }
+    return void 0;
+  };
+}
+function stringAttribute(element2, name) {
+  const value2 = attributeReader(element2)(name)?.trim();
+  return value2 ? value2 : void 0;
+}
+function integerAttribute(element2, name) {
+  const parsed = Number.parseInt(attributeReader(element2)(name) ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function booleanAttribute(element2, name) {
+  const value2 = attributeReader(element2)(name)?.trim().toLowerCase();
+  if (value2 === "1" || value2 === "true") return true;
+  if (value2 === "0" || value2 === "false") return false;
+  return void 0;
+}
+function descendants2(root, local) {
+  const result2 = [];
+  const visit = (node) => {
+    for (const child4 of Array.from(node.childNodes)) {
+      if (!isElement(child4)) continue;
+      if (child4.localName === local) result2.push(child4);
+      visit(child4);
+    }
+  };
+  visit(root);
+  return result2;
+}
+
+// xlsx/pivot/page-filter-admission.ts
+var integer = (value2, fallback) => value2 === null ? fallback ?? NaN : /^\d+$/.test(value2.trim()) && Number.isSafeInteger(Number(value2)) ? Number(value2) : NaN;
+function assertPageAxisItems(root, pivot, shared, cache2, recordRoot) {
+  if (!pivot.pageFilter) return;
+  const literals = (node) => {
+    const raw2 = node.getAttribute("v");
+    if (node.localName === "x" && (raw2 === null || !/^\d+$/.test(raw2.trim())) || node.localName === "b" && !["0", "1"].includes(raw2 ?? "") || node.localName === "n" && (raw2 === null || !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(raw2.trim())))
+      throw new Error("Unmodeled report cache literal");
+    for (const child4 of elements(node)) literals(child4);
+  };
+  literals(cache2);
+  literals(recordRoot);
+  const cacheFields = children(first(cache2, "cacheFields", NS.x), "cacheField", NS.x);
+  if (pivot.columnField) {
+    const column = children(first(root, "pivotFields", NS.x), "pivotField", NS.x)[pivot.fields.indexOf(pivot.columnField)];
+    const list = first(column, "extLst", NS.x);
+    const extensions = list ? children(list, "ext", NS.x) : [];
+    if (extensions.some(
+      (extension) => children(
+        extension,
+        "pivotField",
+        "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
+      ).some((field) => {
+        const raw2 = field.getAttribute("fillDownLabels");
+        if (raw2 !== null && !["0", "1", "false", "true"].includes(raw2.trim()))
+          throw new Error("Invalid report column label repetition");
+        return booleanAttribute(field, "fillDownLabels") === true;
+      })
+    ))
+      throw new Error("Repeated report column labels are preserved");
+  }
+  if (integer(first(cache2, "cacheFields", NS.x)?.getAttribute("count") ?? null) !== pivot.fields.length || integer(cache2.getAttribute("recordCount")) !== pivot.records.length || integer(recordRoot.getAttribute("count")) !== pivot.records.length)
+    throw new Error("Inconsistent report cache counts");
+  for (const name of [
+    pivot.rowField,
+    pivot.secondRowField,
+    pivot.columnField,
+    pivot.pageFilter.field
+  ].filter(Boolean)) {
+    const field = pivot.fields.indexOf(name);
+    if (integer(first(cacheFields[field], "sharedItems", NS.x)?.getAttribute("count") ?? null) !== shared[field].length)
+      throw new Error("Inconsistent report shared-item counts");
+  }
+  for (const name of ["rowFields", "colFields"]) {
+    const list = first(root, name, NS.x);
+    if (list && integer(list.getAttribute("count")) !== children(list, "field", NS.x).length)
+      throw new Error("Inconsistent report axis counts");
+  }
+  const projected = pivotPageProjection(pivot), fields = children(first(root, "pivotFields", NS.x), "pivotField", NS.x);
+  const axisValues = (name, axis) => {
+    const f6 = pivot.fields.indexOf(name), node = fields[f6], list = first(node, "items", NS.x), items = children(list, "item", NS.x), count2 = shared[f6].length;
+    if (node.getAttribute("axis") !== axis) throw new Error("Inconsistent report axis field");
+    const defaults = node.getAttribute("defaultSubtotal") !== "0";
+    if (!list || integer(list.getAttribute("count")) !== items.length || items.length !== count2 + Number(defaults))
+      throw new Error("Incomplete page-axis field items");
+    const data = items.slice(0, count2).map((item) => {
+      const i2 = integer(item.getAttribute("x"));
+      if (item.hasAttribute("t") || !Number.isInteger(i2) || i2 >= count2)
+        throw new Error("Invalid page-axis cache item");
+      return shared[f6][i2];
+    });
+    if (new Set(data.map(pivotValueKey)).size !== count2 || defaults && (items.at(-1)?.getAttribute("t") !== "default" || items.at(-1)?.hasAttribute("x")))
+      throw new Error("Invalid page-axis default item");
+    const indices = new Map(data.map((v, i2) => [pivotValueKey(v), i2]));
+    return pivotItems(projected, name).map((v) => indices.get(pivotValueKey(v)));
+  };
+  const read = (name) => {
+    const list = first(root, name, NS.x), items = children(list, "i", NS.x);
+    if (!list || integer(list.getAttribute("count")) !== items.length)
+      throw new Error("Invalid page-axis item count");
+    return items;
+  };
+  const rows = axisValues(pivot.rowField, "axisRow"), rowItems = read("rowItems");
+  const grid = pivotGrid(pivot);
+  const entries = grid.rowEntries ? remapPivotRowEntries(grid.rowEntries, [
+    rows,
+    pivot.secondRowField ? axisValues(pivot.secondRowField, "axisRow") : []
+  ]) : [
+    ...rows.map((index3) => ({ indices: [index3], type: void 0 })),
+    { indices: [0], type: "grand" }
+  ];
+  if (rowItems.length !== entries.length) throw new Error("Invalid page row items");
+  let previousRow = [];
+  rowItems.forEach((item, i2) => {
+    const expected2 = entries[i2];
+    const xs = children(item, "x", NS.x).map((x) => integer(x.getAttribute("v"), 0)), prefix = integer(item.getAttribute("r"), 0);
+    if (item.getAttribute("t") !== (expected2.type ?? null) || !Number.isInteger(prefix) || prefix < 0 || prefix > previousRow.length || prefix >= expected2.indices.length || expected2.type && prefix !== 0 || integer(item.getAttribute("i"), 0) !== 0 || JSON.stringify([...previousRow.slice(0, prefix), ...xs]) !== JSON.stringify(expected2.indices))
+      throw new Error("Unmodeled page row item");
+    previousRow = expected2.type ? [] : expected2.indices;
+  });
+  const measures = 1 + (pivot.additionalValues?.length ?? 0), columns = pivot.columnField ? axisValues(pivot.columnField, "axisCol") : void 0, expected = [];
+  if (columns)
+    for (const col of columns)
+      for (let m = 0; m < measures; m++) expected.push(measures > 1 ? [col, m] : [col]);
+  else for (let m = 0; m < measures; m++) expected.push([m]);
+  const colItems = read("colItems");
+  if (colItems.length !== expected.length + (columns ? measures : 0))
+    throw new Error("Invalid page column items");
+  let previous = [];
+  colItems.forEach((item, i2) => {
+    const grand = i2 >= expected.length, measure = grand ? i2 - expected.length : i2 % measures;
+    const xs = children(item, "x", NS.x).map((x) => integer(x.getAttribute("v"), 0)), prefix = integer(item.getAttribute("r"), 0);
+    if (integer(item.getAttribute("i"), 0) !== measure || !Number.isInteger(prefix) || prefix < 0 || prefix > Math.max(0, previous.length - 1))
+      throw new Error("Invalid page column prefix");
+    if (grand) {
+      if (item.getAttribute("t") !== "grand" || prefix !== 0 || xs.length !== 1 || xs[0] !== 0)
+        throw new Error("Unmodeled page grand item");
+      previous = [];
+      return;
+    }
+    const values2 = !columns && measures === 1 && xs.length === 0 && prefix === 0 ? [0] : [...previous.slice(0, prefix), ...xs];
+    if (item.hasAttribute("t") || JSON.stringify(values2) !== JSON.stringify(expected[i2]))
+      throw new Error("Unmodeled page column item");
+    previous = values2;
+  });
+}
+
 // xlsx/pivot/read.ts
 function value(node) {
   const v = att(node, "v") ?? "";
@@ -6792,22 +7443,24 @@ function readOne(workbook, source2, part) {
   const dataSheet = sourceNode && att(sourceNode, "sheet");
   const dataRange = sourceNode && parseRange(att(sourceNode, "ref") ?? "");
   const recordPart = source2.targetOfType(cachePart, `${NS.r}/pivotCacheRecords`);
+  const rowsAxis = att(root, "dataOnRows") === "1";
   if (!dataSheet || !dataRange || !recordPart || !workbook.sheets.some((sheet) => sheet.name === dataSheet))
     throw new Error("Unsupported pivot source");
-  assertPivotRecords(parseXml(source2.text(recordPart)).documentElement);
+  const recordRoot = parseXml(source2.text(recordPart)).documentElement;
+  assertPivotRecords(recordRoot);
   const fields = children(first(cache2, "cacheFields", NS.x), "cacheField", NS.x);
   if (fields.some((field) => first(field, "fieldGroup", NS.x) || field.hasAttribute("formula")))
     throw new Error("Grouped or calculated cache field");
   const shared = fields.map(
     (field) => elements(first(field, "sharedItems", NS.x) ?? parseXml("<root/>").documentElement).map(value)
   );
-  const records = children(parseXml(source2.text(recordPart)).documentElement, "r", NS.x).map(
+  const records = children(recordRoot, "r", NS.x).map(
     (record) => elements(record).map((node, field) => {
       if (node.localName !== "x") return value(node);
-      const index2 = Number(att(node, "v"));
-      if (!Number.isInteger(index2) || index2 < 0 || index2 >= (shared[field]?.length ?? 0))
+      const index3 = Number(att(node, "v"));
+      if (!Number.isInteger(index3) || index3 < 0 || index3 >= (shared[field]?.length ?? 0))
         throw new Error("Invalid pivot cache index");
-      return shared[field][index2];
+      return shared[field][index3];
     })
   );
   if (records.some((record) => record.length !== fields.length) || records.length * fields.length > 1e6)
@@ -6827,17 +7480,43 @@ function readOne(workbook, source2, part) {
     "dataField",
     NS.x
   );
-  if (rowFields.length < 1 || rowFields.length > 2 || colFields.length > 1 || dataFields.length !== 1 || first(root, "pageFields", NS.x) || first(root, "filters", NS.x) || root.getAttribute("rowGrandTotals") === "0" || root.getAttribute("colGrandTotals") === "0")
+  if (rowFields.length < 1 || rowFields.length > (rowsAxis ? 3 : 2) || dataFields.length < 1 || dataFields.length > 16 || !supportedPivotAxes(rowFields, colFields, dataFields.length, rowsAxis) || first(root, "filters", NS.x) || root.getAttribute("rowGrandTotals") === "0" || root.getAttribute("colGrandTotals") === "0")
     throw new Error("Unsupported pivot layout");
+  const valueIndex = pivotValueIndex(root, rowsAxis ? rowFields : colFields);
   const measure = dataFields[0];
+  const definition = elements(first(root, "extLst", NS.x) ?? parseXml("<root/>").documentElement).map(
+    (extension) => first(
+      extension,
+      "pivotTableDefinition",
+      "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
+    )
+  ).find(Boolean);
+  if (dataFields.length > 1 && att(definition, "hideValuesRow") !== "1")
+    throw new Error("Visible Values header rows are preserved");
+  for (const [axis, count2] of [
+    ["rowItems", rowsAxis ? dataFields.length : 1],
+    ["colItems", rowsAxis ? 1 : dataFields.length]
+  ]) {
+    for (const item of children(
+      first(root, axis, NS.x) ?? parseXml("<root/>").documentElement,
+      "i",
+      NS.x
+    )) {
+      const index3 = Number(att(item, "i") ?? "0");
+      if (!Number.isInteger(index3) || index3 < 0 || index3 >= count2)
+        throw new Error("Unsupported Values axis item");
+    }
+  }
   const aggregate3 = att(measure, "subtotal") ?? "sum";
   if (!PIVOT_AGGREGATES.includes(aggregate3) || att(measure, "showDataAs") && att(measure, "showDataAs") !== "normal")
     throw new Error("Unsupported pivot aggregate");
   const names = fields.map((field) => decodeEscapes(att(field, "name") ?? ""));
-  const row2 = names[Number(att(rowFields[0], "x"))];
-  const second = rowFields[1] && names[Number(att(rowFields[1], "x"))];
+  const realRows = rowsAxis ? rowFields.filter((field) => pivotFieldIndex(field) !== -2) : rowFields;
+  const row2 = names[pivotFieldIndex(realRows[0])];
+  const second = realRows[1] ? names[Number(att(realRows[1], "x"))] : void 0;
+  const pageFilter = readPivotPageFilter(root, names, shared);
   const tableFields = children(first(root, "pivotFields", NS.x), "pivotField", NS.x);
-  const outer = tableFields[Number(att(rowFields[0], "x"))];
+  const outer = tableFields[pivotFieldIndex(realRows[0])];
   const compact = att(outer, "compact") !== "0";
   const outline = att(outer, "outline") !== "0";
   const layout3 = compact ? "compact" : outline ? "outline" : "tabular";
@@ -6846,7 +7525,7 @@ function readOne(workbook, source2, part) {
   ) || att(root, "compact") !== "0" !== compact || att(root, "compactData") !== "0" !== compact || att(root, "outline") === "1" !== outline || att(root, "outlineData") === "1" !== outline || layout3 === "compact" && att(root, "indent") !== "0")
     throw new Error("Mixed field layouts or custom compact indentation are preserved");
   const subtotal = att(outer, "defaultSubtotal") !== "0";
-  const repeat = rowFields.map((field) => {
+  const repeat = realRows.map((field) => {
     const node = tableFields[Number(att(field, "x"))];
     const extension = first(first(node, "extLst", NS.x), "ext", NS.x);
     return att(
@@ -6859,16 +7538,24 @@ function readOne(workbook, source2, part) {
     ) === "1";
   });
   if (repeat.some((entry4) => entry4 !== repeat[0])) throw new Error("Mixed field label repetition");
-  const col = colFields[0] && names[Number(att(colFields[0], "x"))];
+  const hasColumn = colFields.length > (dataFields.length > 1 && !rowsAxis ? 1 : 0);
+  const col = hasColumn ? names[Number(att(colFields[0], "x"))] : void 0;
   const data = names[Number(att(measure, "fld"))];
   const location = parseRange(att(first(root, "location", NS.x), "ref") ?? "");
-  if (!row2 || !data || !location || colFields.length && !col || rowFields.length === 2 && !second)
+  if (!row2 || !data || !location || hasColumn && !col || realRows.length === 2 && !second)
     throw new Error("Invalid pivot fields");
+  if (pageFilter) {
+    if (location.start.row < 2) throw new Error("Invalid report filter location");
+    location.start.row -= 2;
+  }
   const pivot = {
+    ...pageFilter ? { pageFilter } : {},
     name: att(root, "name") ?? "PivotTable",
     source: `${quoteSheetName(dataSheet)}!${formatRange(dataRange)}`,
     rowField: row2,
     layout: layout3,
+    ...rowsAxis ? { valuesAxis: "rows" } : {},
+    ...rowsAxis && realRows.length === 2 && valueIndex < 2 ? { valuesPosition: valueIndex === 0 ? "first" : "between" } : {},
     subtotalPosition: att(outer, "subtotalTop") === "0" ? "bottom" : "top",
     ...second ? { secondRowField: second, subtotals: subtotal, repeatLabels: repeat[0] ?? false } : {
       ...subtotal ? {} : { subtotals: false },
@@ -6877,6 +7564,15 @@ function readOne(workbook, source2, part) {
     valueField: data,
     aggregate: aggregate3,
     valueCaption: decodeEscapes(att(measure, "name") ?? data),
+    ...dataFields.length > 1 ? {
+      additionalValues: dataFields.slice(1).map((measure2) => {
+        const field = names[Number(att(measure2, "fld"))];
+        const aggregate4 = att(measure2, "subtotal") ?? "sum";
+        if (!field || !PIVOT_AGGREGATES.includes(aggregate4) || att(measure2, "showDataAs") && att(measure2, "showDataAs") !== "normal")
+          throw new Error("Unsupported pivot measure");
+        return { field, aggregate: aggregate4, caption: decodeEscapes(att(measure2, "name") ?? field) };
+      })
+    } : {},
     fields: names,
     records,
     location,
@@ -6885,6 +7581,7 @@ function readOne(workbook, source2, part) {
     sourceXml: xml,
     ...col ? { columnField: col } : {}
   };
+  assertPageAxisItems(root, pivot, shared, cache2, recordRoot);
   return pivot;
 }
 function readPivotTables(workbook, source2, warn) {
@@ -7210,10 +7907,10 @@ function parseDynamicArrayMetadata(xml) {
     const flag2 = props?.getAttribute("fDynamic");
     return flag2 === "1" || flag2 === "true";
   });
-  childrenNamed(top.get("cellMetadata")?.[0], "bk").forEach((bk, index2) => {
+  childrenNamed(top.get("cellMetadata")?.[0], "bk").forEach((bk, index3) => {
     for (const rc of childrenNamed(bk, "rc")) {
       const type = types[Number(att(rc, "t")) - 1];
-      if (type === DYNAMIC_ARRAY_TYPE && dynamic[Number(att(rc, "v"))]) out.add(index2 + 1);
+      if (type === DYNAMIC_ARRAY_TYPE && dynamic[Number(att(rc, "v"))]) out.add(index3 + 1);
     }
   });
   return out;
@@ -7491,13 +8188,13 @@ function parseStyles(xml, warnings) {
     const named2 = namesByXf.get(xfId);
     if (named2 && xfId !== 0 && named2 !== "Normal") style2.cellStyleName = named2;
     const key = styleKey(style2);
-    let index2 = keys.get(key);
-    if (index2 === void 0) {
-      index2 = styles.length;
+    let index3 = keys.get(key);
+    if (index3 === void 0) {
+      index3 = styles.length;
       styles.push(style2);
-      keys.set(key, index2);
+      keys.set(key, index3);
     }
-    xfMap.push(index2);
+    xfMap.push(index3);
   }
   if (!styles.length) {
     styles.push(fallback);
@@ -7511,47 +8208,6 @@ function parseStyles(xml, warnings) {
   return result2;
 }
 
-// drawingml/dom.ts
-function attributeReader(element2) {
-  return (name) => {
-    if (!element2) return void 0;
-    const direct = element2.getAttribute(name);
-    if (direct !== null) return direct;
-    const attributes = element2.attributes;
-    for (let index2 = 0; index2 < attributes.length; index2++) {
-      const candidate = attributes.item(index2);
-      if (candidate && candidate.localName === name) return candidate.value;
-    }
-    return void 0;
-  };
-}
-function stringAttribute(element2, name) {
-  const value2 = attributeReader(element2)(name)?.trim();
-  return value2 ? value2 : void 0;
-}
-function integerAttribute(element2, name) {
-  const parsed = Number.parseInt(attributeReader(element2)(name) ?? "", 10);
-  return Number.isFinite(parsed) ? parsed : void 0;
-}
-function booleanAttribute(element2, name) {
-  const value2 = attributeReader(element2)(name)?.trim().toLowerCase();
-  if (value2 === "1" || value2 === "true") return true;
-  if (value2 === "0" || value2 === "false") return false;
-  return void 0;
-}
-function descendants2(root, local) {
-  const result2 = [];
-  const visit = (node) => {
-    for (const child4 of Array.from(node.childNodes)) {
-      if (!isElement(child4)) continue;
-      if (child4.localName === local) result2.push(child4);
-      visit(child4);
-    }
-  };
-  visit(root);
-  return result2;
-}
-
 // drawingml/drawing-color.ts
 var COLOR_ELEMENTS = {
   srgbClr: "srgb",
@@ -7697,7 +8353,7 @@ function parseTheme2(xml) {
   if (!xml) return palette;
   const theme = parseTheme(parseXml(xml, { label: "XLSX theme" }));
   palette.colors = PALETTE_SLOTS.map(
-    (slot2, index2) => paletteHex(theme.colorScheme.colors[slot2]) ?? DEFAULT_THEME.colors[index2] ?? "000000"
+    (slot2, index3) => paletteHex(theme.colorScheme.colors[slot2]) ?? DEFAULT_THEME.colors[index3] ?? "000000"
   );
   palette.majorFont = theme.fontScheme.major.latin ?? palette.majorFont;
   palette.minorFont = theme.fontScheme.minor.latin ?? palette.minorFont;
@@ -8085,11 +8741,11 @@ function readModernHash(node, prefix = "") {
 function parseWorkbookPart(xml) {
   const root = parseXml(xml, { label: "XLSX workbook" }).documentElement;
   const sheets = [];
-  xChildren(xFirst(root, "sheets") ?? root, "sheet").forEach((node, index2) => {
+  xChildren(xFirst(root, "sheets") ?? root, "sheet").forEach((node, index3) => {
     const state = att(node, "state");
     sheets.push({
-      name: att(node, "name") ?? `Sheet${index2 + 1}`,
-      sheetId: numAttr(node, "sheetId") ?? index2 + 1,
+      name: att(node, "name") ?? `Sheet${index3 + 1}`,
+      sheetId: numAttr(node, "sheetId") ?? index3 + 1,
       state: state === "hidden" || state === "veryHidden" ? state : "visible",
       relId: relAttr(node, "id") ?? ""
     });
@@ -8439,8 +9095,8 @@ function styleRef(element2) {
   if (element2.localName === "fontRef") {
     if (raw2) ref.fontIndex = raw2;
   } else {
-    const index2 = Number.parseInt(raw2 ?? "", 10);
-    if (Number.isFinite(index2)) ref.index = index2;
+    const index3 = Number.parseInt(raw2 ?? "", 10);
+    if (Number.isFinite(index3)) ref.index = index3;
   }
   const color = parseDrawingColorIn(element2);
   if (color) ref.color = color;
@@ -8819,11 +9475,11 @@ function groupTransform(group, parent) {
     scaleY: parent.scaleY * local.scaleY
   };
 }
-function parseShape(sp, index2, group, issues) {
+function parseShape(sp, index3, group, issues) {
   const spPr = first(sp, "spPr", NS.dsp);
   const transform6 = parseTransform(first(spPr, "xfrm", NS.a));
   if (!transform6) return void 0;
-  const modelId = stringAttribute(sp, "modelId") ?? stringAttribute(first(first(sp, "nvSpPr", NS.dsp), "cNvPr", NS.dsp), "id") ?? `dsp-${index2}`;
+  const modelId = stringAttribute(sp, "modelId") ?? stringAttribute(first(first(sp, "nvSpPr", NS.dsp), "cNvPr", NS.dsp), "id") ?? `dsp-${index3}`;
   const { geometry, adjustments, paths, issue } = parseDrawingGeometry(spPr);
   if (issue) issues.push({ code: issue, message: `Shape ${modelId}: ${issue}.` });
   const frame = applyGroup(transform6.frame, group);
@@ -9041,8 +9697,8 @@ function drawingFillXml(fill) {
   const stops = children(list, "gs", NS.a).filter(
     (node) => parseDrawingColorIn(node) && Number.isFinite(Number.parseInt(node.getAttribute("pos") ?? "", 10))
   );
-  fill.stops.forEach((stop, index2) => {
-    const node = stops[index2] ?? doc.createElementNS(NS.a, "a:gs");
+  fill.stops.forEach((stop, index3) => {
+    const node = stops[index3] ?? doc.createElementNS(NS.a, "a:gs");
     if (!node.parentNode) list.appendChild(node);
     node.setAttribute("pos", String(Math.round(stop.position * 1e3)));
     for (const old of elements(node))
@@ -9551,45 +10207,6 @@ function readDataValidations(node) {
   return out;
 }
 
-// xlsx/write/xml-out.ts
-var XML_HEADER = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
-var CONTROL = "\0-\b\v\f-" + String.fromCharCode(65534, 65535);
-var NEEDS_ESCAPE = new RegExp(`[${CONTROL}\r]|_x[0-9A-Fa-f]{4}_`);
-var ESCAPABLE = new RegExp(`[${CONTROL}\r]|_(?=x[0-9A-Fa-f]{4}_)`, "g");
-function encodeEscapes(text) {
-  if (!NEEDS_ESCAPE.test(text)) return text;
-  return text.replace(
-    ESCAPABLE,
-    (ch) => `_x${ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}_`
-  );
-}
-var INVALID_XML = new RegExp(`[${CONTROL}]`, "g");
-var escapeText2 = (text) => text.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-var escapeAttr3 = (text) => text.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;").replace(/\t/g, "&#9;");
-function attrs(values2) {
-  let out = "";
-  for (const [name, value2] of Object.entries(values2)) {
-    if (value2 === void 0) continue;
-    const text = typeof value2 === "boolean" ? value2 ? "1" : "0" : typeof value2 === "number" ? num(value2) : value2;
-    out += ` ${name}="${escapeAttr3(text)}"`;
-  }
-  return out;
-}
-var el = (name, values2 = {}, content2 = "") => content2 ? `<${name}${attrs(values2)}>${content2}</${name}>` : `<${name}${attrs(values2)}/>`;
-var num = (value2) => Object.is(value2, -0) ? "0" : String(value2);
-function tElement(text, name = "t") {
-  const encoded = escapeText2(encodeEscapes(text));
-  const preserve = /^\s|\s$|\n|\t/.test(text) ? ' xml:space="preserve"' : "";
-  return `<${name}${preserve}>${encoded}</${name}>`;
-}
-var MAIN_NS = ' xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"';
-function inlineFragment(xml) {
-  const end = xml.indexOf(">");
-  if (end < 0) return xml;
-  const head = xml.slice(0, end);
-  return head.includes(MAIN_NS) ? head.replace(MAIN_NS, "") + xml.slice(end) : xml;
-}
-
 // xlsx/conditional-extensions.ts
 var XM = "http://schemas.microsoft.com/office/excel/2006/main";
 var URI = "{78C0D931-6437-407d-A8EE-F0AAD7539E65}";
@@ -9599,8 +10216,8 @@ function writeSettings(node, rule) {
   if (rule.minLength !== void 0) bar.setAttribute("minLength", String(rule.minLength));
   if (rule.maxLength !== void 0) bar.setAttribute("maxLength", String(rule.maxLength));
   const thresholds = children(bar, "cfvo", NS.x14);
-  for (const [index2, threshold] of [rule.min, rule.max].entries()) {
-    const target = thresholds[index2];
+  for (const [index3, threshold] of [rule.min, rule.max].entries()) {
+    const target = thresholds[index3];
     if (!target) continue;
     const oldType = target.getAttribute("type");
     if (oldType === "autoMin" && threshold.type === "min" || oldType === "autoMax" && threshold.type === "max")
@@ -9864,7 +10481,7 @@ function chartCacheValues(cache2) {
     out[point.index ?? out.length] = numeric2 && text.trim() !== "" && Number.isFinite(Number(text)) ? Number(text) : text;
   }
   const size = Math.max(cache2.pointCount ?? 0, out.length);
-  for (let index2 = 0; index2 < size; index2++) if (out[index2] === void 0) out[index2] = "";
+  for (let index3 = 0; index3 < size; index3++) if (out[index3] === void 0) out[index3] = "";
   return out;
 }
 var chartSourceValues = (source2) => chartCacheValues(source2?.cache ?? source2?.levels?.[0]);
@@ -9999,8 +10616,8 @@ function parseCache(node) {
     type: node.localName === "numCache" || node.localName === "numLit" ? "number" : "string",
     points: children(node, "pt", NS.c).map((pt) => {
       const point = { value: cChild(pt, "v")?.textContent ?? "" };
-      const index2 = Number(attribute(pt, "idx") ?? Number.NaN);
-      if (Number.isInteger(index2) && index2 >= 0) point.index = index2;
+      const index3 = Number(attribute(pt, "idx") ?? Number.NaN);
+      if (Number.isInteger(index3) && index3 >= 0) point.index = index3;
       const formatCode2 = attribute(pt, "formatCode");
       if (formatCode2 !== void 0) point.formatCode = formatCode2;
       return point;
@@ -10226,11 +10843,11 @@ var POINT = /* @__PURE__ */ new Set([
 ]);
 function parseDataPoint(context, element2) {
   reportUnmodelled(context, element2, POINT);
-  const index2 = cNumber(context, element2, "idx");
+  const index3 = cNumber(context, element2, "idx");
   return assignDefined(
     {},
     {
-      index: index2 !== void 0 && Number.isInteger(index2) && index2 >= 0 ? index2 : void 0,
+      index: index3 !== void 0 && Number.isInteger(index3) && index3 >= 0 ? index3 : void 0,
       invertIfNegative: cBool(context, element2, "invertIfNegative"),
       bubble3D: cBool(context, element2, "bubble3D"),
       explosion: cNumber(context, element2, "explosion"),
@@ -10767,8 +11384,8 @@ var SCHEME_INDEX = {
 function legacyColor(color) {
   if (color?.kind === "srgb") return color.value ? { rgb: color.value.toUpperCase() } : void 0;
   if (color?.kind === "scheme") {
-    const index2 = SCHEME_INDEX[color.value];
-    return index2 === void 0 ? void 0 : { theme: index2 };
+    const index3 = SCHEME_INDEX[color.value];
+    return index3 === void 0 ? void 0 : { theme: index3 };
   }
   return void 0;
 }
@@ -11619,14 +12236,14 @@ var PersonRegistry = class {
     return `${XML_HEADER}<personList xmlns="${NS.tc}" xmlns:x="${NS.x}">${people}</personList>`;
   }
 };
-function vmlShape(comment, index2, id) {
+function vmlShape(comment, index3, id) {
   const { row: row2, col } = comment.address;
   const anchor = `${col + 1}, 15, ${Math.max(0, row2 - 1)}, 10, ${col + 3}, 15, ${row2 + 3}, 4`;
-  return `<v:shape id="_x0000_s${id}" type="#_x0000_t202" style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;z-index:${index2 + 1};visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto"><v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/><v:path o:connecttype="none"/><v:textbox style="mso-direction-alt:auto"><div style="text-align:left"></div></v:textbox><x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>${anchor}</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>${row2}</x:Row><x:Column>${col}</x:Column></x:ClientData></v:shape>`;
+  return `<v:shape id="_x0000_s${id}" type="#_x0000_t202" style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;z-index:${index3 + 1};visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto"><v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/><v:path o:connecttype="none"/><v:textbox style="mso-direction-alt:auto"><div style="text-align:left"></div></v:textbox><x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>${anchor}</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>${row2}</x:Row><x:Column>${col}</x:Column></x:ClientData></v:shape>`;
 }
 var NOTE_SHAPETYPE = '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/><v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype>';
 function vmlXml(comments, layout3) {
-  const shapes = comments.map((comment, index2) => vmlShape(comment, index2, layout3.ids[index2] ?? 0)).join("");
+  const shapes = comments.map((comment, index3) => vmlShape(comment, index3, layout3.ids[index3] ?? 0)).join("");
   const data = layout3.blocks.join(",");
   const base = layout3.base;
   if (base && /<\/xml>\s*$/.test(base)) {
@@ -11657,8 +12274,8 @@ function commentParts(comments, sheetNumber, persons, sheetName, layout3) {
       const id = guidFrom(`${sheetName}!${ref}:${comment.text}`);
       const personId = persons.id(comment.author);
       threaded += `<threadedComment ref="${ref}" personId="${personId}" id="${id}"><text>${escapeText2(comment.text)}</text></threadedComment>`;
-      comment.replies.forEach((reply, index2) => {
-        const replyId = guidFrom(`${id}:reply:${index2}:${reply.text}`);
+      comment.replies.forEach((reply, index3) => {
+        const replyId = guidFrom(`${id}:reply:${index3}:${reply.text}`);
         const dT = reply.date ? ` dT="${escapeAttr3(reply.date)}"` : "";
         threaded += `<threadedComment ref="${ref}"${dT} personId="${persons.id(reply.author)}" id="${replyId}" parentId="${id}"><text>${escapeText2(reply.text)}</text></threadedComment>`;
       });
@@ -11675,7 +12292,7 @@ Reply:
     sorted2,
     layout3 ?? {
       blocks: [sheetNumber],
-      ids: sorted2.map((_, index2) => 1024 * sheetNumber + index2 + 1)
+      ids: sorted2.map((_, index3) => 1024 * sheetNumber + index3 + 1)
     }
   );
   const parts = { comments: commentsXml, vml };
@@ -12378,11 +12995,11 @@ var GRAY_VARIATIONS = [
   { tint: 8e4 }
 ];
 var ACCENTS = ["accent1", "accent2", "accent3", "accent4", "accent5", "accent6"];
-function colorful(id, index2, base) {
-  return { id, group: "colorful", index: index2, meth: "cycle", base, variations: COLORFUL_VARIATIONS };
+function colorful(id, index3, base) {
+  return { id, group: "colorful", index: index3, meth: "cycle", base, variations: COLORFUL_VARIATIONS };
 }
-function mono(id, index2, accent, meth) {
-  return { id, group: "monochromatic", index: index2, meth, base: [accent], variations: [] };
+function mono(id, index3, accent, meth) {
+  return { id, group: "monochromatic", index: index3, meth, base: [accent], variations: [] };
 }
 var CHART_COLOR_PALETTES = [
   colorful(10, 1, ACCENTS),
@@ -12426,9 +13043,9 @@ function chartPaletteSeriesColorChoice(palette, i2, n) {
     const round2 = Math.floor(i2 / palette.base.length);
     transform6 = (palette.variations.length ? palette.variations[round2 % palette.variations.length] : {}) ?? {};
   } else {
-    const index2 = palette.meth === "withinLinearReversed" ? n - 1 - i2 : i2;
+    const index3 = palette.meth === "withinLinearReversed" ? n - 1 - i2 : i2;
     base = palette.base[0];
-    transform6 = withinLinearTransform(index2, n);
+    transform6 = withinLinearTransform(index3, n);
   }
   if (!base) throw new RangeError("A chart palette must have a base color");
   return {
@@ -12609,18 +13226,18 @@ var PackageWriter = class {
 var rank = (name) => name === "_rels/.rels" ? 0 : name.startsWith("docProps/") ? 1 : name === "xl/workbook.xml" ? 2 : 3;
 
 // xlsx/write/chart-colors.ts
-function chartSeriesFill(chart, series, index2) {
+function chartSeriesFill(chart, series, index3) {
   const imported = series.fill && drawingFillXml(series.fill);
   if (imported) return imported;
-  return `<a:solidFill>${drawingColorXml(chartSeriesColor(chart, series, index2))}</a:solidFill>`;
+  return `<a:solidFill>${drawingColorXml(chartSeriesColor(chart, series, index3))}</a:solidFill>`;
 }
-function chartSeriesDrawingFill(chart, series, index2) {
+function chartSeriesDrawingFill(chart, series, index3) {
   if (series.fill && drawingFillXml(series.fill)) return series.fill;
-  return { kind: "solid", color: chartSeriesColor(chart, series, index2) };
+  return { kind: "solid", color: chartSeriesColor(chart, series, index3) };
 }
-function chartSeriesColor(chart, series, index2) {
+function chartSeriesColor(chart, series, index3) {
   const palette = findChartColorPalette(chart.colorPalette ?? 10);
-  return series.drawingColor ?? chartDrawingColor(series.color) ?? chartPaletteSeriesColorChoice(palette ?? findChartColorPalette(10), index2, chart.series.length);
+  return series.drawingColor ?? chartDrawingColor(series.color) ?? chartPaletteSeriesColorChoice(palette ?? findChartColorPalette(10), index3, chart.series.length);
 }
 function recolorMarker(marker3, previous, next) {
   for (const paint of [marker3, first(marker3, "ln", NS.a)]) {
@@ -12638,10 +13255,10 @@ function patchChartColors(doc, chartNode, model, before) {
   const palette = findChartColorPalette(model.colorPalette ?? 10);
   const lineLike = ["line", "scatter", "radar"].includes(model.chartType);
   const markerOnly = model.chartType === "scatter" && first(plot2, "scatterStyle", NS.c)?.getAttribute("val") === "marker";
-  children(plot2, "ser", NS.c).forEach((ser, index2) => {
-    const series = model.series[index2];
+  children(plot2, "ser", NS.c).forEach((ser, index3) => {
+    const series = model.series[index3];
     if (!series) return;
-    const old = before.series[index2];
+    const old = before.series[index3];
     if (old?.effectsXml !== series.effectsXml) {
       let shape2 = first(ser, "spPr", NS.c);
       if (!shape2 && series.effectsXml) {
@@ -12687,12 +13304,12 @@ function patchChartColors(doc, chartNode, model, before) {
         paint = doc.createElementNS(NS.a, "a:ln");
         spPr.appendChild(paint);
       }
-      setDrawingFillXml(paint, chartSeriesFill(model, series, index2));
+      setDrawingFillXml(paint, chartSeriesFill(model, series, index3));
     }
     if (previousPalette && palette && before.colorPalette !== model.colorPalette) {
       const marker3 = first(first(ser, "marker", NS.c), "spPr", NS.c);
-      const previous = chartPaletteSeriesColorChoice(previousPalette, index2, model.series.length);
-      const next = chartPaletteSeriesColorChoice(palette, index2, model.series.length);
+      const previous = chartPaletteSeriesColorChoice(previousPalette, index3, model.series.length);
+      const next = chartPaletteSeriesColorChoice(palette, index3, model.series.length);
       recolorMarker(marker3, previous, next);
       for (const point of children(ser, "dPt", NS.c))
         recolorMarker(first(first(point, "marker", NS.c), "spPr", NS.c), previous, next);
@@ -12787,7 +13404,7 @@ var FIRST_AXIS = 500000001;
 var SECOND_AXIS = 500000002;
 function source(kind, formula, values2) {
   const points = values2.flatMap(
-    (value2, index2) => value2 === null || value2 === "" ? [] : [{ index: index2, value: String(value2) }]
+    (value2, index3) => value2 === null || value2 === "" ? [] : [{ index: index3, value: String(value2) }]
   );
   return {
     kind: formula ? kind === "str" ? "strRef" : "numRef" : kind === "str" ? "strLit" : "numLit",
@@ -12820,9 +13437,9 @@ function dataPoints(series) {
     return /^\d+$/.test(key) && paint ? [{ index: Number(key), spPr: { fill: paint } }] : [];
   });
 }
-function seriesModel(chart, series, index2) {
+function seriesModel(chart, series, index3) {
   const type = chart.chartType;
-  const out = { index: index2, order: index2, dataPoints: dataPoints(series) };
+  const out = { index: index3, order: index3, dataPoints: dataPoints(series) };
   if (series.nameRef)
     out.tx = {
       reference: source("str", series.nameRef, series.name === void 0 ? [] : [series.name])
@@ -12831,7 +13448,7 @@ function seriesModel(chart, series, index2) {
   const lineLike = type === "line" || type === "scatter" || type === "radar";
   const effectsXml = effects(series);
   if (type !== "pie" && type !== "doughnut" || series.fill || series.color || series.drawingColor || effectsXml) {
-    const fill = chartSeriesDrawingFill(chart, series, index2);
+    const fill = chartSeriesDrawingFill(chart, series, index3);
     const shape2 = lineLike ? { line: { widthEmu: 28575, cap: "rnd", fill } } : { fill };
     if (effectsXml) shape2.effectsXml = effectsXml;
     out.spPr = shape2;
@@ -12955,7 +13572,7 @@ function style(chart) {
   return id > 100 ? { c14Style: id, style: id - 100 } : { style: id };
 }
 function chartSpaceFromObject(chart) {
-  const series = chart.series.map((entry3, index2) => seriesModel(chart, entry3, index2));
+  const series = chart.series.map((entry3, index3) => seriesModel(chart, entry3, index3));
   const [group, chartAxes] = plot(chart, series);
   const space = {
     roundedCorners: false,
@@ -12996,8 +13613,8 @@ function patchChartReferences(xml, chart) {
       changed = true;
     }
   };
-  children(plot2, "ser", NS.c).forEach((ser, index2) => {
-    const model = chart.series[index2];
+  children(plot2, "ser", NS.c).forEach((ser, index3) => {
+    const model = chart.series[index3];
     if (!model) return;
     setRef(first(ser, "tx", NS.c), model.nameRef);
     setRef(first(ser, "cat", NS.c) ?? first(ser, "xVal", NS.c), model.categoriesRef);
@@ -13365,10 +13982,10 @@ var MONTHS2 = [
 function monthFromName2(name) {
   const lower2 = name.toLowerCase();
   if (lower2.length < 3) return void 0;
-  const index2 = MONTHS2.findIndex((m) => lower2.startsWith(m));
-  if (index2 < 0) return void 0;
-  const full = new Date(Date.UTC(2e3, index2, 1)).toLocaleString("en-US", { month: "long", timeZone: "UTC" }).toLowerCase();
-  return lower2.length === 3 || full.startsWith(lower2) || lower2 === "sept" ? index2 + 1 : void 0;
+  const index3 = MONTHS2.findIndex((m) => lower2.startsWith(m));
+  if (index3 < 0) return void 0;
+  const full = new Date(Date.UTC(2e3, index3, 1)).toLocaleString("en-US", { month: "long", timeZone: "UTC" }).toLowerCase();
+  return lower2.length === 3 || full.startsWith(lower2) || lower2 === "sept" ? index3 + 1 : void 0;
 }
 var NUMBER_RE3 = /^(\d+(?:,\d{3,})+|\d*)(\.\d*)?(?:e([+-]?\d+))?$/i;
 var TIME_RE2 = /^(\d{1,4})(?::(\d+))?(?::(\d+(?:\.\d*)?))?(?:\s+(am|pm|a|p))?$/i;
@@ -14136,11 +14753,11 @@ function sort(args, ctx) {
   if (byCol) m = transpose(m);
   const indexes2 = args.length > 1 && args[1] !== null ? ctx.toMatrix(args[1] ?? null).flat().map((v) => Math.trunc(num2(v))) : [1];
   const orders = args.length > 2 && args[2] !== null ? ctx.toMatrix(args[2] ?? null).flat().map((v) => num2(v)) : [1];
-  const keys = indexes2.map((index2, k) => {
-    if (index2 < 1 || index2 > m.cols) fail(ERR.VALUE);
+  const keys = indexes2.map((index3, k) => {
+    if (index3 < 1 || index3 > m.cols) fail(ERR.VALUE);
     const order = orders[Math.min(k, orders.length - 1)] ?? 1;
     if (order !== 1 && order !== -1) fail(ERR.VALUE);
-    return { values: m.data.map((row2) => row2[index2 - 1] ?? null), descending: order === -1 };
+    return { values: m.data.map((row2) => row2[index3 - 1] ?? null), descending: order === -1 };
   });
   const sorted2 = new Matrix(sortRows(m.data, keys));
   return byCol ? transpose(sorted2) : sorted2;
@@ -14268,14 +14885,14 @@ var ARRAY_FUNCTIONS = [
       const cols = optInt(ctx, args, 1, 1);
       const min = args.length > 2 && args[2] !== null ? num2(ctx.toScalar(args[2] ?? null)) : 0;
       const max = args.length > 3 && args[3] !== null ? num2(ctx.toScalar(args[3] ?? null)) : 1;
-      const integer = args.length > 4 && args[4] !== null && toBool(ctx.toScalar(args[4] ?? null));
+      const integer2 = args.length > 4 && args[4] !== null && toBool(ctx.toScalar(args[4] ?? null));
       if (rows < 1 || cols < 1) return ERR.CALC;
       if (min > max) fail(ERR.VALUE);
       const random = () => ctx.frame.host.random();
       return Matrix.build(
         rows,
         cols,
-        () => integer ? Math.ceil(min) + Math.floor(random() * (Math.floor(max) - Math.ceil(min) + 1)) : min + random() * (max - min)
+        () => integer2 ? Math.ceil(min) + Math.floor(random() * (Math.floor(max) - Math.ceil(min) + 1)) : min + random() * (max - min)
       );
     },
     ["any"],
@@ -14330,8 +14947,8 @@ function modes(values2) {
 function kth(values2, k, largest) {
   const n = values2.length;
   if (n === 0 || !(k >= 1) || k > n) fail(ERR.NUM);
-  const index2 = Math.floor(largest ? n + 1 - k : k) - 1;
-  return sorted(values2)[index2];
+  const index3 = Math.floor(largest ? n + 1 - k : k) - 1;
+  return sorted(values2)[index3];
 }
 function extreme(values2, max) {
   if (values2.length === 0) return 0;
@@ -14471,13 +15088,13 @@ function fieldIndex(table2, field) {
   const value2 = scalar(field);
   if (isError(value2)) fail(value2);
   if (typeof value2 === "number") {
-    const index3 = Math.trunc(value2) - 1;
-    if (index3 < 0 || index3 >= table2.headers.length) fail(ERR.VALUE);
-    return index3;
+    const index4 = Math.trunc(value2) - 1;
+    if (index4 < 0 || index4 >= table2.headers.length) fail(ERR.VALUE);
+    return index4;
   }
-  const index2 = table2.headers.indexOf(label2(value2).toLowerCase());
-  if (index2 < 0) fail(ERR.VALUE);
-  return index2;
+  const index3 = table2.headers.indexOf(label2(value2).toLowerCase());
+  if (index3 < 0) fail(ERR.VALUE);
+  return index3;
 }
 function recordFilter(table2, criteria) {
   const [head, ...rows] = criteria;
@@ -15763,8 +16380,8 @@ function cumulative(args, principal) {
 
 // xlsx/formula/functions/bonds.ts
 var C9 = "Financial";
-var basisOf = (args, index2) => {
-  const basis = args.length > index2 && args[index2] !== null ? int3(args[index2]) : 0;
+var basisOf = (args, index3) => {
+  const basis = args.length > index3 && args[index3] !== null ? int3(args[index3]) : 0;
   if (basis < 0 || basis > 4) fail(ERR.NUM);
   return basis;
 };
@@ -15946,9 +16563,9 @@ var AMORLINC = {
       }
       const fraction = purchase === firstPeriod ? 1 : basis === 1 ? (firstPeriod - purchase) / (isLeapYear(serialToYmd(purchase, ctx.date1904).year) ? 366 : 365) : yearFrac(purchase, firstPeriod, basis, ctx);
       const first2 = Math.min(cost - salvage, annual * fraction);
-      const index2 = Math.trunc(period);
-      if (index2 === 0) return first2;
-      return Math.max(0, Math.min(annual, cost - salvage - first2 - (index2 - 1) * annual));
+      const index3 = Math.trunc(period);
+      if (index3 === 0) return first2;
+      return Math.max(0, Math.min(annual, cost - salvage - first2 - (index3 - 1) * annual));
     }
   ),
   missingRequiredError: "#N/A"
@@ -16175,8 +16792,8 @@ var DEPRECIATION_FUNCTIONS = [
 
 // xlsx/formula/functions/securities.ts
 var C11 = "Financial";
-var basisOf2 = (args, index2) => {
-  const basis = args.length > index2 && args[index2] !== null ? int3(args[index2]) : 0;
+var basisOf2 = (args, index3) => {
+  const basis = args.length > index3 && args[index3] !== null ? int3(args[index3]) : 0;
   if (basis < 0 || basis > 4) fail(ERR.NUM);
   return basis;
 };
@@ -16599,8 +17216,8 @@ var INFO_FUNCTIONS = [
       const v = args[0];
       if (v === void 0) return ctx.sheet + 1;
       if (v instanceof RefValue) return (v.areas[0]?.sheet ?? ctx.sheet) + 1;
-      const index2 = sheetIndex(ctx.frame.host, str(v));
-      return index2 < 0 ? ERR.NA : index2 + 1;
+      const index3 = sheetIndex(ctx.frame.host, str(v));
+      return index3 < 0 ? ERR.NA : index3 + 1;
     },
     ["any"]
   ),
@@ -17069,14 +17686,14 @@ function shape(value2) {
   if (value2 instanceof Matrix) return { rows: value2.rows, cols: value2.cols };
   return { rows: 1, cols: 1 };
 }
-function line(ctx, value2, axis, index2) {
+function line(ctx, value2, axis, index3) {
   if (value2 instanceof RefValue) {
     const area = value2.areas[0];
     if (!area || value2.areas.length !== 1) fail(ERR.VALUE);
     const { start, end } = area.range;
     const bounds = ctx.frame.host.bounds(area.sheet);
     if (axis === "col") {
-      const col = start.col + index2;
+      const col = start.col + index3;
       const length2 = Math.max(0, Math.min(end.row, bounds.rows - 1) - start.row + 1);
       return {
         length: length2,
@@ -17084,7 +17701,7 @@ function line(ctx, value2, axis, index2) {
         get: (i2) => ctx.readCell(area.sheet, start.row + i2, col)
       };
     }
-    const row2 = start.row + index2;
+    const row2 = start.row + index3;
     const length = Math.max(0, Math.min(end.col, bounds.cols - 1) - start.col + 1);
     return {
       length,
@@ -17093,8 +17710,8 @@ function line(ctx, value2, axis, index2) {
     };
   }
   const m = value2 instanceof Matrix ? value2 : new Matrix([[value2]]);
-  if (axis === "col") return { length: m.rows, get: (i2) => m.get(i2, index2) };
-  return { length: m.cols, get: (i2) => m.get(index2, i2) };
+  if (axis === "col") return { length: m.rows, get: (i2) => m.get(i2, index3) };
+  return { length: m.cols, get: (i2) => m.get(index3, i2) };
 }
 function vectorOf(ctx, value2) {
   const { rows, cols } = shape(value2);
@@ -17532,24 +18149,24 @@ function cellOf(value2, row2, col) {
   if (value2 instanceof Matrix) return value2.get(row2, col);
   return value2;
 }
-function sliceOf(value2, axis, index2) {
+function sliceOf(value2, axis, index3) {
   const { rows } = shape(value2);
   if (value2 instanceof RefValue) {
     const area = value2.areas[0];
     if (!area) fail(ERR.REF);
     const { start, end } = area.range;
     const range = axis === "row" ? {
-      start: { row: start.row + index2, col: start.col },
-      end: { row: start.row + index2, col: end.col }
+      start: { row: start.row + index3, col: start.col },
+      end: { row: start.row + index3, col: end.col }
     } : {
-      start: { row: start.row, col: start.col + index2 },
-      end: { row: end.row, col: start.col + index2 }
+      start: { row: start.row, col: start.col + index3 },
+      end: { row: end.row, col: start.col + index3 }
     };
     return new RefValue([{ sheet: area.sheet, range }]);
   }
   const m = value2 instanceof Matrix ? value2 : new Matrix([[value2]]);
-  if (axis === "row") return new Matrix([m.data[index2] ?? []]);
-  return new Matrix(Array.from({ length: rows }, (_, r) => [m.get(r, index2)]));
+  if (axis === "row") return new Matrix([m.data[index3] ?? []]);
+  return new Matrix(Array.from({ length: rows }, (_, r) => [m.get(r, index3)]));
 }
 function lookupValue(args) {
   const v = scalar(args[0]);
@@ -17565,15 +18182,15 @@ function lookupArray(value2) {
 function vhlookup(args, ctx, vertical) {
   const lookup2 = blankAsZero(args);
   const table2 = lookupArray(args[1] ?? null);
-  const index2 = int3(args[2]);
+  const index3 = int3(args[2]);
   const approximate2 = args.length < 4 ? true : bool(args[3]);
   const { rows, cols } = shape(table2);
-  if (index2 < 1) fail(ERR.VALUE);
-  if (index2 > (vertical ? cols : rows)) fail(ERR.REF);
+  if (index3 < 1) fail(ERR.VALUE);
+  if (index3 > (vertical ? cols : rows)) fail(ERR.REF);
   const keys = line(ctx, table2, vertical ? "col" : "row", 0);
   const at = approximate2 ? findAscending(keys, lookup2) : findExact(keys, lookup2, true);
   if (at < 0) fail(ERR.NA);
-  return vertical ? cellOf(table2, at, index2 - 1) : cellOf(table2, index2 - 1, at);
+  return vertical ? cellOf(table2, at, index3 - 1) : cellOf(table2, index3 - 1, at);
 }
 function match(args, ctx) {
   const lookup2 = blankAsZero(args);
@@ -17600,13 +18217,13 @@ function lookup(args, ctx) {
   if (at < 0) fail(ERR.NA);
   return vertical ? cellOf(source2, at, cols - 1) : cellOf(source2, rows - 1, at);
 }
-function index(args) {
+function index2(args) {
   const source2 = args[0] ?? null;
   if (source2 instanceof RefValue && source2.areas.length > 1) {
     const area = Math.trunc(optNum(args, 3, 1));
     const chosen = source2.areas[area - 1];
     if (!chosen) fail(ERR.REF);
-    return index([new RefValue([chosen]), ...args.slice(1, 3)]);
+    return index2([new RefValue([chosen]), ...args.slice(1, 3)]);
   }
   const { rows, cols } = shape(source2);
   let r = args.length > 1 && args[1] !== null ? int3(args[1]) : 0;
@@ -17728,7 +18345,7 @@ var LOOKUP_FUNCTIONS = [
     "The value or reference at a position.",
     1,
     4,
-    (args) => index(args),
+    (args) => index2(args),
     ["any", "value", "value", "value"]
   ),
   spec(
@@ -17772,27 +18389,27 @@ function valueKeys(value2, out) {
   }
 }
 function positionsOf(block, key) {
-  let index2 = indexes.get(block);
-  if (!index2) {
+  let index3 = indexes.get(block);
+  if (!index3) {
     const count2 = (uses.get(block) ?? 0) + 1;
     uses.set(block, count2);
     if (count2 < 2 || block.isPadded) return void 0;
-    index2 = /* @__PURE__ */ new Map();
+    index3 = /* @__PURE__ */ new Map();
     const keys = [];
     const cols = block.cols;
     for (let r = 0; r < block.rows; r++) {
       for (let c2 = 0; c2 < cols; c2++) {
         valueKeys(block.get(r, c2), keys);
         for (const k of keys) {
-          const list = index2.get(k);
+          const list = index3.get(k);
           if (list) list.push(r * cols + c2);
-          else index2.set(k, [r * cols + c2]);
+          else index3.set(k, [r * cols + c2]);
         }
       }
     }
-    indexes.set(block, index2);
+    indexes.set(block, index3);
   }
-  return index2.get(key) ?? [];
+  return index3.get(key) ?? [];
 }
 
 // xlsx/formula/functions/criteria.ts
@@ -18952,7 +19569,7 @@ function layout(ctx, args) {
   }
   return { y, x, column };
 }
-var withConst = (args, index2) => omitted(args, index2) ? true : bool(args[index2]);
+var withConst = (args, index3) => omitted(args, index3) ? true : bool(args[index3]);
 var row = (values2, width) => [
   ...values2,
   ...new Array(Math.max(0, width - values2.length)).fill(ERR.NA)
@@ -21266,7 +21883,7 @@ function compile(pattern, caseMode2, global) {
     return fail(ERR.VALUE);
   }
 }
-var caseMode = (args, index2) => optNum(args, index2, 0);
+var caseMode = (args, index3) => optNum(args, index3, 0);
 function encodeUrl(text) {
   return encodeURIComponent(text).replace(
     /[!'()*]/g,
@@ -21385,9 +22002,9 @@ function textAround(args, ctx, before) {
     if (instance > 0) found.push({ at: text.length, length: 0 });
     else found.unshift({ at: 0, length: 0 });
   }
-  const index2 = instance > 0 ? instance - 1 : found.length + instance;
-  const hit = found[index2];
-  if (!hit || index2 < 0) return notFound;
+  const index3 = instance > 0 ? instance - 1 : found.length + instance;
+  const hit = found[index3];
+  if (!hit || index3 < 0) return notFound;
   return before ? text.slice(0, hit.at) : text.slice(hit.at + hit.length);
 }
 function splitText(text, delimiters, insensitive, ignoreEmpty) {
@@ -21503,10 +22120,10 @@ Object.freeze(
 );
 
 // xlsx/formula/functions/types.ts
-var paramKind = (spec2, index2) => {
+var paramKind = (spec2, index3) => {
   const params = spec2.params;
   if (!params || params.length === 0) return "value";
-  return params[Math.min(index2, params.length - 1)] ?? "value";
+  return params[Math.min(index3, params.length - 1)] ?? "value";
 };
 
 // xlsx/formula/spill.ts
@@ -22086,9 +22703,9 @@ function readSourceStyles(xml) {
     (node) => inlineFragment(outerXml(node))
   );
   const dxfKeys = /* @__PURE__ */ new Map();
-  parseStyles(xml, []).dxfs.forEach((dxf, index2) => {
+  parseStyles(xml, []).dxfs.forEach((dxf, index3) => {
     const key = styleKey(dxf);
-    if (!dxfKeys.has(key)) dxfKeys.set(key, index2);
+    if (!dxfKeys.has(key)) dxfKeys.set(key, index3);
   });
   const result2 = { numFmts, dxfXml, dxfKeys };
   const tableStyles = xFirst(root, "tableStyles");
@@ -22196,7 +22813,7 @@ var StyleWriter = class {
       });
     const seen = /* @__PURE__ */ new Set();
     const unique2 = named2.filter((entry3) => !seen.has(entry3.name) && seen.add(entry3.name));
-    const xfIdOf = new Map(unique2.map((entry3, index2) => [entry3.name, index2]));
+    const xfIdOf = new Map(unique2.map((entry3, index3) => [entry3.name, index3]));
     const base = this.workbook.styles[0] ?? defaultCellStyle();
     this.fonts.id(fontXml(base.font));
     this.borders.id(borderXml({}));
@@ -22205,7 +22822,7 @@ var StyleWriter = class {
       (style2) => this.xf(style2, xfIdOf.get(style2.cellStyleName ?? "Normal") ?? 0)
     );
     const cellStyles = unique2.map(
-      (entry3, index2) => el("cellStyle", { name: entry3.name, xfId: index2, builtinId: entry3.builtinId })
+      (entry3, index3) => el("cellStyle", { name: entry3.name, xfId: index3, builtinId: entry3.builtinId })
     );
     const custom = [...this.numFmts].filter(([code]) => builtinFormatIdOf(code) === void 0).sort((a2, b) => a2[1] - b[1]);
     let out = `${XML_HEADER}<styleSheet xmlns="${NS.x}" xmlns:mc="${NS.mc}" mc:Ignorable="x14ac" xmlns:x14ac="${NS.x14ac}">`;
@@ -22370,13 +22987,13 @@ function definedNamesOf(workbook) {
   const names = workbook.definedNames.filter(
     (name) => name.name && (name.localSheet === void 0 || name.localSheet >= 0 && name.localSheet < workbook.sheets.length)
   );
-  workbook.sheets.forEach((sheet, index2) => {
+  workbook.sheets.forEach((sheet, index3) => {
     const area = sheet.pageSetup?.printArea;
-    if (!area || names.some((n) => n.name === "_xlnm.Print_Area" && n.localSheet === index2)) return;
+    if (!area || names.some((n) => n.name === "_xlnm.Print_Area" && n.localSheet === index3)) return;
     names.push({
       name: "_xlnm.Print_Area",
       formula: `${quoteSheetName(sheet.name)}!${absoluteRange(area)}`,
-      localSheet: index2
+      localSheet: index3
     });
   });
   return names;
@@ -22995,9 +23612,9 @@ function sourceColumnsForPatch(root, table2, names) {
   const byName = new Map(source2.map((c2) => [(c2.getAttribute("name") ?? "").toLowerCase(), c2]));
   const tracked = table2.partName !== void 0 || table2.columns.some((c2) => c2.sourceId !== void 0);
   const used = /* @__PURE__ */ new Set();
-  return names.map((name, index2) => {
-    const id = table2.columns[index2]?.sourceId;
-    const match2 = id !== void 0 ? byId.get(id) : tracked ? void 0 : source2.length === names.length ? source2[index2] : byName.get(name.toLowerCase());
+  return names.map((name, index3) => {
+    const id = table2.columns[index3]?.sourceId;
+    const match2 = id !== void 0 ? byId.get(id) : tracked ? void 0 : source2.length === names.length ? source2[index3] : byName.get(name.toLowerCase());
     if (!match2 || used.has(match2)) return void 0;
     used.add(match2);
     return match2;
@@ -23014,12 +23631,12 @@ function patchAutoFilter(doc, root, table2, before, names) {
   filter2.setAttribute("ref", formatRange(range));
   const list = xKid(root, "tableColumns");
   const original = list ? xKids(list, "tableColumn") : [];
-  const current = new Map(sourceColumnsForPatch(root, table2, names).map((c2, index2) => [c2, index2]));
+  const current = new Map(sourceColumnsForPatch(root, table2, names).map((c2, index3) => [c2, index3]));
   for (const column of xKids(filter2, "filterColumn")) {
     const old = original[Number(column.getAttribute("colId") ?? "0")];
-    const index2 = old ? current.get(old) : void 0;
-    if (index2 === void 0) filter2.removeChild(column);
-    else column.setAttribute("colId", num(index2));
+    const index3 = old ? current.get(old) : void 0;
+    if (index3 === void 0) filter2.removeChild(column);
+    else column.setAttribute("colId", num(index3));
   }
   if (!existing) insertBefore(root, filter2, ["sortState", "tableColumns"]);
   const sort2 = xKid(filter2, "sortState") ?? xKid(root, "sortState");
@@ -23064,11 +23681,11 @@ function patchColumns(doc, root, sheet, table2, names) {
   for (const column of sourceColumns) list.removeChild(column);
   let nextId = Math.max(0, ...ids) + 1;
   const totalsRow = table2.range.end.row;
-  names.forEach((name, index2) => {
-    const column = picked[index2] ?? doc.createElementNS(NS.x, "tableColumn");
+  names.forEach((name, index3) => {
+    const column = picked[index3] ?? doc.createElementNS(NS.x, "tableColumn");
     if (!column.getAttribute("id")) column.setAttribute("id", num(nextId++));
     column.setAttribute("name", name);
-    const model = table2.columns[index2];
+    const model = table2.columns[index3];
     const fn = table2.totalsRow ? model?.totalsRowFunction : void 0;
     setOrRemove(column, "totalsRowFunction", fn);
     setOrRemove(column, "totalsRowLabel", table2.totalsRow ? model?.totalsRowLabel : void 0);
@@ -23082,7 +23699,7 @@ function patchColumns(doc, root, sheet, table2, names) {
     );
     if (fn !== "custom") setChildText(doc, column, "totalsRowFormula", void 0, []);
     else {
-      const cellFormula = sheet.rows.get(totalsRow)?.get(table2.range.start.col + index2)?.formula;
+      const cellFormula = sheet.rows.get(totalsRow)?.get(table2.range.start.col + index3)?.formula;
       if (cellFormula)
         setChildText(
           doc,
@@ -23163,11 +23780,11 @@ function tableXml(table2, id, names) {
   const range = formatRange(table2.range);
   const filterEnd = { ...table2.range.end, row: table2.range.end.row - (table2.totalsRow ? 1 : 0) };
   const filter2 = table2.headerRow && !table2.totalsRow ? `<autoFilter ref="${range}"/>` : table2.headerRow ? `<autoFilter ref="${formatRange({ start: table2.range.start, end: filterEnd })}"/>` : "";
-  const columns = names.map((name, index2) => {
-    const column = table2.columns[index2];
+  const columns = names.map((name, index3) => {
+    const column = table2.columns[index3];
     const calculated = column?.calculatedColumnFormula ? `<calculatedColumnFormula>${escapeText2(addFuturePrefixes(column.calculatedColumnFormula))}</calculatedColumnFormula>` : "";
     const values2 = attrs({
-      id: index2 + 1,
+      id: index3 + 1,
       name,
       totalsRowFunction: table2.totalsRow ? column?.totalsRowFunction : void 0,
       totalsRowLabel: table2.totalsRow ? column?.totalsRowLabel : void 0
@@ -23206,27 +23823,27 @@ function totalsRowFormulas(sheet, table2, names) {
   const out = /* @__PURE__ */ new Map();
   if (!table2.totalsRow) return out;
   const row2 = table2.range.end.row;
-  names.forEach((name, index2) => {
-    const code = SUBTOTAL_CODES[table2.columns[index2]?.totalsRowFunction ?? ""];
+  names.forEach((name, index3) => {
+    const code = SUBTOTAL_CODES[table2.columns[index3]?.totalsRowFunction ?? ""];
     if (code === void 0) return;
-    const col = table2.range.start.col + index2;
+    const col = table2.range.start.col + index3;
     const escaped = name.replace(/['#[\]]/g, "'$&");
     const formula = `SUBTOTAL(${code},${table2.displayName || table2.name}[${escaped}])`;
     if (sheet.rows.get(row2)?.get(col)?.formula !== formula) out.set(`${row2}:${col}`, formula);
   });
   return out;
 }
-function resolveTableNames(table2, before, index2) {
+function resolveTableNames(table2, before, index3) {
   const display = table2.displayName || table2.name;
-  const displayName = before && before.displayName === display ? display : safeTableName(display, index2);
-  const name = before && before.name === table2.name ? table2.name : table2.name === display ? displayName : safeTableName(table2.name, index2);
+  const displayName = before && before.displayName === display ? display : safeTableName(display, index3);
+  const name = before && before.name === table2.name ? table2.name : table2.name === display ? displayName : safeTableName(table2.name, index3);
   return { name, displayName };
 }
-function safeTableName(name, index2) {
+function safeTableName(name, index3) {
   const valid = /^[A-Za-z_\\][A-Za-z0-9_.\\]*$/.test(name) && !/^[A-Za-z]{1,3}\d+$/.test(name) && !/^[RrCc]$/.test(name) && !/^[Rr]\d*[Cc]\d*$/.test(name) && name.length <= 255;
   if (valid) return name;
   const cleaned = name.replace(/[^A-Za-z0-9_.]/g, "_");
-  return `Table_${cleaned || index2}`;
+  return `Table_${cleaned || index3}`;
 }
 
 // xlsx/write/sheet-parts.ts
@@ -23239,7 +23856,7 @@ function sourceRelIds(source2, partName) {
   if (legacy) out.legacy = legacy;
   return out;
 }
-function writeComments(ctx, sheet, index2, partName, rels) {
+function writeComments(ctx, sheet, index3, partName, rels) {
   const { writer, source: source2 } = ctx;
   const name = (pattern) => writer.uniqueName(pattern, ctx.reserved);
   const fromSource = source2 && sheet.partName && source2.has(sheet.partName);
@@ -23284,8 +23901,8 @@ function writeComments(ctx, sheet, index2, partName, rels) {
     }
   }
   const own = base ? vmlIdmapBlocks(base) : [];
-  const layout3 = vmlAllocatorFor(ctx, source2).allocate(sheet.comments.length, index2 + 1, own);
-  const parts = commentParts(sheet.comments, index2 + 1, ctx.persons, sheet.name, {
+  const layout3 = vmlAllocatorFor(ctx, source2).allocate(sheet.comments.length, index3 + 1, own);
+  const parts = commentParts(sheet.comments, index3 + 1, ctx.persons, sheet.name, {
     ...layout3,
     ...base ? { base } : {}
   });
@@ -23307,11 +23924,11 @@ function sourceVmlPart(source2, sheetPart) {
 }
 function writeTables(ctx, sheet, partName, rels, headerText, formulas) {
   const ids = [];
-  for (const [index2, original] of sheet.tables.entries()) {
+  for (const [index3, original] of sheet.tables.entries()) {
     const { writer, source: source2 } = ctx;
     const sourceXml = original.partName ? source2?.text(original.partName) : void 0;
     const before = sourceXml && original.partName ? parseTable(sourceXml, original.partName) : void 0;
-    const { name, displayName } = resolveTableNames(original, before, index2 + 1);
+    const { name, displayName } = resolveTableNames(original, before, index3 + 1);
     const table2 = name === original.name && displayName === original.displayName ? original : { ...original, name, displayName };
     const { names, headerText: forced } = resolveTableColumns(sheet, table2);
     for (const [key, text] of forced) headerText.set(key, text);
@@ -23593,7 +24210,7 @@ var REGENERATED = /* @__PURE__ */ new Set([
 ]);
 var NS_XR2 = "http://schemas.microsoft.com/office/spreadsheetml/2015/revision2";
 var NS_XR3 = "http://schemas.microsoft.com/office/spreadsheetml/2016/revision3";
-function writeWorksheet(ctx, sheet, index2, partName) {
+function writeWorksheet(ctx, sheet, index3, partName) {
   const { writer, source: source2 } = ctx;
   const rels = new RelationshipSet();
   let sourceDrawing;
@@ -23616,7 +24233,7 @@ function writeWorksheet(ctx, sheet, index2, partName) {
   const tableParts = writeTables(ctx, sheet, partName, rels, headerText, formulas);
   blocks.set("sheetPr", sheetPrXml(sheet));
   blocks.set("dimension", dimensionXml(sheet));
-  blocks.set("sheetViews", sheetViewsXml(sheet, index2 === ctx.workbook.activeSheet));
+  blocks.set("sheetViews", sheetViewsXml(sheet, index3 === ctx.workbook.activeSheet));
   blocks.set("sheetFormatPr", sheetFormatXml(sheet));
   blocks.set("cols", colsXml(sheet, ctx.workbook.styles.length));
   blocks.set(
@@ -23655,7 +24272,7 @@ function writeWorksheet(ctx, sheet, index2, partName) {
   );
   blocks.set("headerFooter", page.headerFooter);
   blocks.set("drawing", writeSheetDrawing(ctx, sheet, partName, rels, sourceDrawing));
-  blocks.set("legacyDrawing", writeComments(ctx, sheet, index2, partName, rels));
+  blocks.set("legacyDrawing", writeComments(ctx, sheet, index3, partName, rels));
   blocks.set("tableParts", tableParts);
   ctx.pivots?.writeSheet(writer, sheet, partName, rels);
   blocks.set("extLst", conditionalExtensionsXml(sheet));
@@ -23680,12 +24297,12 @@ 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 value2 = record[index2] ?? null;
+    pivot.fields.forEach((_field, index3) => {
+      const value2 = record[index3] ?? null;
       const key = pivotValueKey(value2);
-      if (!indices[index2].has(key)) {
-        indices[index2].set(key, items[index2].length);
-        items[index2].push(value2);
+      if (!indices[index3].has(key)) {
+        indices[index3].set(key, items[index3].length);
+        items[index3].push(value2);
       }
     });
   return { items, indices };
@@ -23700,8 +24317,8 @@ function valueXml(value2) {
 }
 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 fields = pivot.fields.map((name, index3) => {
+    const items = data.items[index3];
     const types = new Set(
       items.map((value2) => value2 === null || value2 === "" ? "blank" : typeof value2)
     );
@@ -23713,7 +24330,7 @@ function pivotCacheDefinitionXml(pivot, workbook, data, recordRel) {
 }
 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>`
+    (record) => `<r>${pivot.fields.map((_field, index3) => `<x v="${data.indices[index3].get(pivotValueKey(record[index3] ?? null))}"/>`).join("")}</r>`
   ).join("");
   return `${XML_HEADER}<pivotCacheRecords xmlns="${NS.x}" count="${pivot.records.length}">${records}</pivotCacheRecords>`;
 }
@@ -23723,45 +24340,87 @@ 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 page = pivot.pageFilter ? pivot.fields.indexOf(pivot.pageFilter.field) : -1;
+  const pageItems = page >= 0 ? pivotItems(pivot, pivot.pageFilter.field) : [];
+  const axisItems = (field, visible) => page >= 0 ? pivotItems(pivot, field) : visible;
+  const rowItemsFull = axisItems(pivot.rowField, grid.rowItems);
+  const secondRowItemsFull = pivot.secondRowField ? axisItems(pivot.secondRowField, grid.secondRowItems) : [];
+  const columnItemsFull = pivot.columnField ? axisItems(pivot.columnField, grid.columnItems) : [];
+  const itemIndices = (visible, full) => {
+    const indices = new Map(full.map((item, index3) => [pivotValueKey(item), index3]));
+    return visible.map((v) => indices.get(pivotValueKey(v)));
+  };
+  const rowIndicesFull = itemIndices(grid.rowItems, rowItemsFull), secondRowIndicesFull = itemIndices(grid.secondRowItems ?? [], secondRowItemsFull), columnIndicesFull = itemIndices(grid.columnItems, columnItemsFull);
+  const rowEntries = page >= 0 && grid.rowEntries ? remapPivotRowEntries(grid.rowEntries, [rowIndicesFull, secondRowIndicesFull]) : grid.rowEntries;
+  const pageOffset = page >= 0 ? 2 : 0;
   const col = pivot.columnField ? pivot.fields.indexOf(pivot.columnField) : -1;
-  const value2 = pivot.fields.indexOf(pivot.valueField);
+  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: index2 === value2 ? 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>`;
+  const fields = pivot.fields.map((_field, index3) => {
+    const items2 = index3 === page ? pageItems : index3 === row2 ? rowItemsFull : index3 === second ? secondRowItemsFull : index3 === col ? columnItemsFull : void 0;
+    const subtotal = !(index3 === row2 && pivot.subtotals === false);
+    const repeated = pivot.repeatLabels && (index3 === row2 || index3 === 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: index3 === page ? "axisPage" : index3 === row2 || index3 === second ? "axisRow" : index3 === col ? "axisCol" : void 0, dataField: measures.some((measure) => pivot.fields.indexOf(measure.field) === index3) ? true : void 0, compact, outline, showAll: false, subtotalTop: index3 === row2 ? top : void 0, defaultSubtotal: subtotal ? void 0 : false })}>${items2 ? `<items count="${items2.length + Number(subtotal)}">${items2.map((item) => `<item x="${cache2.indices[index3].get(pivotValueKey(item))}"/>`).join("")}${subtotal ? '<item t="default"/>' : ""}</items>` : ""}${repeated}</pivotField>`;
   }).join("");
-  const items = (count2) => Array.from({ length: count2 }, (_v, i2) => `<i><x v="${i2}"/></i>`).join("") + '<i t="grand"><x/></i>';
-  const header = grid.firstDataRow - 1;
-  const rowIndices = [row2, ...second >= 0 ? [second] : []];
+  const items = (count2, indices) => Array.from({ length: count2 }, (_v, i2) => `<i><x v="${indices?.[i2] ?? i2}"/></i>`).join("") + '<i t="grand"><x/></i>';
+  const header = grid.firstHeaderRow !== void 0 ? grid.firstHeaderRow - pageOffset : multiple && col >= 0 ? 1 : grid.firstDataRow - pageOffset - 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) => {
+  const rowItems = rowEntries?.map((entry3) => {
     let prefix = 0;
-    if (!entry3.type)
+    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.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: value2, subtotal: pivot.aggregate, baseField: 0, baseItem: 0 })}/></dataFields>`;
+    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((index3) => `<x${attrs({ v: index3 || void 0 })}/>`).join("")}</i>`;
+  }).join("") ?? items(grid.rowItems.length, rowIndicesFull);
+  let body = `<location${attrs({ ref: formatRange({ ...pivot.location, start: { ...pivot.location.start, row: pivot.location.start.row + pageOffset } }), firstHeaderRow: header, firstDataRow: grid.firstDataRow - pageOffset, rowPageCount: page >= 0 ? 1 : void 0, colPageCount: page >= 0 ? 1 : void 0, firstDataCol: grid.rowLabelColumns ?? 1 })}/><pivotFields count="${pivot.fields.length}">${fields}</pivotFields><rowFields count="${rowIndices.length}">${rowIndices.map((index3) => `<field x="${index3}"/>`).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, columnIndicesFull)}`;
+  else if (col >= 0)
+    body += `<colFields count="1"><field x="${col}"/></colFields><colItems count="${grid.columnItems.length + 1}">${items(grid.columnItems.length, columnIndicesFull)}</colItems>`;
+  else
+    body += rowsAxis ? '<colItems count="1"><i/></colItems>' : page >= 0 ? '<colItems count="1"><i/></colItems>' : '<colItems count="1"><i><x/></i></colItems>';
+  if (page >= 0)
+    body += `<pageFields count="1"><pageField${attrs({ fld: page, hier: -1, item: pivot.pageFilter.item !== void 0 ? pageItems.findIndex((item) => pivotValueKey(item) === pivotValueKey(pivot.pageFilter.item)) : void 0 })}/></pageFields>`;
+  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(
@@ -23772,6 +24431,7 @@ function pivotTableXml(pivot, cacheId, cache2) {
       "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");
   }
@@ -23782,7 +24442,8 @@ function pivotTableXml(pivot, cacheId, cache2) {
     "rowItems",
     "colFields",
     "colItems",
-    "dataFields"
+    "dataFields",
+    "pageFields"
   ]);
   for (const child4 of elements(root)) if (replaced.has(child4.localName)) root.removeChild(child4);
   const replacement = parseXml(`<root xmlns="${NS.x}">${body}</root>`).documentElement;
@@ -23967,8 +24628,8 @@ async function saveXlsx(workbook) {
     return void 0;
   });
   const sheetRefs = [];
-  workbook.sheets.forEach((sheet, index2) => {
-    let partName = partNames[index2];
+  workbook.sheets.forEach((sheet, index3) => {
+    let partName = partNames[index3];
     const sourceType = partName && source2?.has(partName) ? source2.contentType(partName) : void 0;
     const special = sourceType ? SHEET_TYPES[sourceType] : void 0;
     if (!partName) {
@@ -23979,11 +24640,11 @@ async function saveXlsx(workbook) {
       claimed.add(partName);
     }
     if (special) writer.carry(partName);
-    else writeWorksheet(ctx, sheet, index2, partName);
+    else writeWorksheet(ctx, sheet, index3, partName);
     sheetRefs.push({
       name: sheet.name,
       sheetId: sheet.sheetId,
-      state: states[index2] ?? "visible",
+      state: states[index3] ?? "visible",
       relId: rels.add(special ?? RELATIONSHIP_TYPES.worksheet, relativeTarget(bookPart, partName))
     });
   });
@@ -24605,10 +25266,10 @@ function hasFlatUniqueStreamLayout(entries, workbookCount) {
   return new Set(names).size === names.length;
 }
 function equalBytes(left2, right2) {
-  return left2.length === right2.length && left2.every((value2, index2) => value2 === right2[index2]);
+  return left2.length === right2.length && left2.every((value2, index3) => value2 === right2[index3]);
 }
 function isCfb(bytes) {
-  return OLE_MAGIC.every((value2, index2) => bytes[index2] === value2);
+  return OLE_MAGIC.every((value2, index3) => bytes[index3] === value2);
 }
 
 // ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/legacy-excel-workbook-functions.js
@@ -25049,9 +25710,9 @@ function decode2(rgce, extra, context, options) {
         break;
       case 25: {
         const ixti = reader.u16();
-        const index2 = reader.u16();
+        const index3 = reader.u16();
         reader.skip(2);
-        const name = context.externName(ixti, index2);
+        const name = context.externName(ixti, index3);
         if (name === void 0)
           return void 0;
         push(name);
@@ -25168,9 +25829,9 @@ var XLS_BUILTIN_FORMATS = {
   48: "##0.0E+0",
   49: "@"
 };
-function paletteColor(index2, palette) {
-  const rgb = index2 < 64 ? palette[index2] : void 0;
-  return rgb ? { index: index2, rgb } : { index: index2, auto: true };
+function paletteColor(index3, palette) {
+  const rgb = index3 < 64 ? palette[index3] : void 0;
+  return rgb ? { index: index3, rgb } : { index: index3, auto: true };
 }
 var UNDERLINE = {
   1: "single",
@@ -25610,18 +26271,18 @@ function parseGlobals(records) {
       }
       return void 0;
     },
-    name(index2) {
-      const raw2 = rawNames[index2 - 1];
+    name(index3) {
+      const raw2 = rawNames[index3 - 1];
       return raw2?.name.name;
     },
-    externName(ixti, index2) {
+    externName(ixti, index3) {
       const xti = xtis[ixti];
       const book = xti ? supbooks[xti.book] : void 0;
       if (!book)
         return void 0;
       if (book.kind === "self")
-        return this.name(index2);
-      return book.externNames[index2 - 1];
+        return this.name(index3);
+      return book.externNames[index3 - 1];
     }
   };
   for (const raw2 of rawNames) {
@@ -25952,8 +26613,8 @@ function parseSheet(bound, records, start, globals) {
     sheet.cells.push(result2);
     return result2;
   };
-  for (let index2 = start; index2 < records.length; index2++) {
-    const record = records[index2];
+  for (let index3 = start; index3 < records.length; index3++) {
+    const record = records[index3];
     const { opcode, data } = record;
     if (opcode === 2057) {
       depth++;
@@ -26161,7 +26822,7 @@ function parseSheet(bound, records, start, globals) {
 
 // ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/legacy-excel-workbook.js
 function compoundStreamNames(bytes) {
-  if (!OLE_MAGIC.every((value2, index2) => bytes[index2] === value2))
+  if (!OLE_MAGIC.every((value2, index3) => bytes[index3] === value2))
     return [];
   try {
     const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
@@ -26173,10 +26834,10 @@ function compoundStreamNames(bytes) {
 function topLevelSubstreams(records) {
   const starts = [];
   let depth = 0;
-  records.forEach((record, index2) => {
+  records.forEach((record, index3) => {
     if (record.opcode === 2057) {
-      if (depth === 0 && index2 > 0)
-        starts.push(index2);
+      if (depth === 0 && index3 > 0)
+        starts.push(index3);
       depth++;
     } else if (record.opcode === 10)
       depth = Math.max(0, depth - 1);
@@ -26201,7 +26862,7 @@ function readXlsWorkbook(bytes) {
     unsupported.push("VBA macros");
   if (streams2.some((name) => name === "_SX_DB_CUR") && !unsupported.includes("pivot caches"))
     unsupported.push("pivot caches");
-  const byOffset = new Map(records.map((record, index2) => [record.offset, index2]));
+  const byOffset = new Map(records.map((record, index3) => [record.offset, index3]));
   const substreams = topLevelSubstreams(records);
   const sheets = globals.sheets.map((bound, position) => {
     const start = byOffset.get(bound.offset) ?? substreams[position];
@@ -26325,7 +26986,7 @@ function layout2(bytes) {
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   if (view.getUint16(0, true) !== 65534 || view.getUint16(2, true) > 1 || view.getUint32(24, true) !== 1)
     return;
-  if (!FMTID.every((value2, index2) => bytes[28 + index2] === value2))
+  if (!FMTID.every((value2, index3) => bytes[28 + index3] === value2))
     return;
   const start = view.getUint32(44, true);
   if (start < 48 || start % 4 || start + 8 > bytes.length)
@@ -26483,8 +27144,8 @@ function xfToCellStyle(xls, xf) {
 }
 function defaultXfIndex(xls) {
   if (xls.xfs[15] && !xls.xfs[15].isStyle) return 15;
-  const index2 = xls.xfs.findIndex((xf) => !xf.isStyle);
-  return index2 >= 0 ? index2 : 0;
+  const index3 = xls.xfs.findIndex((xf) => !xf.isStyle);
+  return index3 >= 0 ? index3 : 0;
 }
 
 // xlsx/load/legacy-xls-sheet.ts
@@ -26678,7 +27339,7 @@ async function loadLegacyXls(input) {
   workbook.sheets = [];
   let undecoded = 0;
   let external = false;
-  xls.sheets.forEach((source2, index2) => {
+  xls.sheets.forEach((source2, index3) => {
     if (source2.kind !== "worksheet") {
       const kind = source2.kind === "chart" ? "chart sheet" : `${source2.kind} sheet`;
       warnings.push(
@@ -26687,7 +27348,7 @@ async function loadLegacyXls(input) {
       return;
     }
     const mapped = mapSheet(source2, workbook.sheets.length + 1, resolve2);
-    sheetIndex2.set(index2, workbook.sheets.length);
+    sheetIndex2.set(index3, workbook.sheets.length);
     workbook.sheets.push(mapped.sheet);
     undecoded += mapped.undecodedFormulas;
     external ||= mapped.externalReferences;
@@ -26796,7 +27457,7 @@ function decodeSpreadsheetText(bytes) {
 var CFB_MAGIC = [208, 207, 17, 224, 161, 177, 26, 225];
 var ZIP_MAGIC = [80, 75, 3, 4];
 var toBytes3 = (input) => input instanceof Uint8Array ? input : new Uint8Array(input);
-var startsWith = (bytes, magic) => magic.every((value2, index2) => bytes[index2] === value2);
+var startsWith = (bytes, magic) => magic.every((value2, index3) => bytes[index3] === value2);
 function zipEntryNames(bytes) {
   const names = /* @__PURE__ */ new Set();
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);