ooxml-core 1.9.0 → 1.11.0

package/dist/teams/index.cjs

@@ -4981,7 +4981,7 @@ var init_ast = __esm({
 });
 
 // xlsx/model.ts
-var ERROR_CODES, isCellError;
+var ERROR_CODES, isErrorCode, isCellError;
 var init_model = __esm({
   "xlsx/model.ts"() {
     ERROR_CODES = [
@@ -4996,6 +4996,7 @@ var init_model = __esm({
       "#SPILL!",
       "#CALC!"
     ];
+    isErrorCode = (value) => ERROR_CODES.includes(value);
     isCellError = (value) => typeof value === "object" && value !== null && "error" in value;
   }
 });
@@ -19976,6 +19977,66 @@ var init_sparkline_ranges = __esm({
   }
 });
 
+// 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 index2 = pivot.fields.indexOf(filter2.field), key = pivotValueKey(filter2.item);
+  const records = pivot.records.filter((record) => pivotValueKey(record[index2] ?? null) === key);
+  if (!records.length) throw new Error("The report filter item is missing from the source.");
+  if (JSON.stringify(records[0][index2] ?? 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 init_page_filter = __esm({
+  "xlsx/pivot/page-filter.ts"() {
+    init_model();
+    init_data();
+  }
+});
+
 // xlsx/pivot/data.ts
 function pivotValueKey(value) {
   return value === null || value === "" ? "blank" : isCellError(value) ? `error:${value.error}` : `${typeof value}:${String(value).toLowerCase()}`;
@@ -20002,12 +20063,32 @@ function pivotItemLabel(value) {
   return isCellError(value) ? value.error : value;
 }
 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.");
 }
@@ -20015,6 +20096,8 @@ var PIVOT_AGGREGATES;
 var init_data = __esm({
   "xlsx/pivot/data.ts"() {
     init_model();
+    init_xml2();
+    init_page_filter();
     PIVOT_AGGREGATES = ["sum", "count", "average", "min", "max"];
   }
 });
@@ -20072,20 +20155,186 @@ var init_cache_xml = __esm({
   }
 });
 
+// xlsx/pivot/measures.ts
+function aggregate2(records, field, type) {
+  if (!records.length) return null;
+  const values2 = records.map((record) => record[field] ?? null);
+  if (type === "count") return values2.filter((value) => value !== null && value !== "").length;
+  const error = values2.find(isCellError);
+  if (error) return error;
+  const numbers3 = values2.filter((value) => typeof value === "number");
+  if (!numbers3.length) return type === "average" ? { error: "#DIV/0!" } : 0;
+  if (type === "min") return numbers3.reduce((a2, b) => Math.min(a2, b));
+  if (type === "max") return numbers3.reduce((a2, b) => Math.max(a2, b));
+  const sum2 = numbers3.reduce((total2, value) => total2 + value, 0);
+  return type === "average" ? sum2 / numbers3.length : sum2;
+}
+function pivotHeaderDimensions(pivot, columnItems, rowLabels) {
+  const measures = 1 + (pivot.additionalValues?.length ?? 0);
+  if (pivot.valuesAxis === "rows")
+    return {
+      rows: (pivot.columnField ? 2 : 1) + (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)
+    ]
+  ];
+}
+var pivotMeasures, pivotMeasureNumber, pivotNumbers;
+var init_measures = __esm({
+  "xlsx/pivot/measures.ts"() {
+    init_model();
+    pivotMeasures = (pivot) => [
+      { field: pivot.valueField, aggregate: pivot.aggregate, caption: pivot.valueCaption },
+      ...pivot.additionalValues ?? []
+    ];
+    pivotMeasureNumber = (pivot, records, measure) => aggregate2(records, pivot.fields.indexOf(measure.field), measure.aggregate);
+    pivotNumbers = (pivot, records) => pivotMeasures(pivot).map((measure) => pivotMeasureNumber(pivot, records, measure));
+  }
+});
+
+// xlsx/pivot/hierarchy-first.ts
+function appendFirstPivotValues(pivot, context) {
+  const {
+    rowItems,
+    secondRowItems,
+    columnItems,
+    children: children2,
+    innerIndices,
+    groups,
+    details,
+    buckets,
+    width,
+    rowLabels,
+    top,
+    bottom,
+    append
+  } = context;
+  const compact = pivot.layout === "compact";
+  const tabular = !pivot.layout || pivot.layout === "tabular";
+  const blank = () => Array(width - rowLabels).fill(null);
+  pivotMeasures(pivot).forEach((measure, m) => {
+    const numbers3 = (keys, records) => [
+      ...columnItems.map(
+        (column) => pivotMeasureNumber(
+          pivot,
+          buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+          measure
+        )
+      ),
+      pivotMeasureNumber(pivot, records, measure)
+    ];
+    if (!tabular)
+      append([measure.caption, ...Array(rowLabels - 1).fill(null)], blank(), {
+        indices: [m],
+        measure: m
+      });
+    let first2 = true;
+    rowItems.forEach((outer, outerIndex) => {
+      const key = pivotValueKey(outer);
+      const group = groups.get(key) ?? [];
+      if (!tabular)
+        append(
+          compact ? [pivotItemLabel(outer)] : [null, pivotItemLabel(outer), null],
+          top ? numbers3([key], group) : blank(),
+          { indices: [m, outerIndex], measure: m },
+          compact ? 1 : 0
+        );
+      const innerKeys = [...children2.get(key)].sort(
+        (a2, b) => innerIndices.get(a2) - innerIndices.get(b)
+      );
+      innerKeys.forEach((innerKey, child3) => {
+        const innerIndex = innerIndices.get(innerKey);
+        append(
+          compact ? [pivotItemLabel(secondRowItems[innerIndex])] : [
+            tabular && first2 ? measure.caption : null,
+            pivot.repeatLabels || tabular && child3 === 0 ? pivotItemLabel(outer) : null,
+            pivotItemLabel(secondRowItems[innerIndex])
+          ],
+          numbers3([key, innerKey], details.get(JSON.stringify([key, innerKey]))),
+          { indices: [m, outerIndex, innerIndex], measure: m },
+          compact ? 2 : 0
+        );
+        first2 = false;
+      });
+      if (bottom)
+        append(
+          compact ? [`${String(pivotItemLabel(outer))} Total`] : [null, `${String(pivotItemLabel(outer))} Total`, null],
+          numbers3([key], group),
+          { indices: [m, outerIndex], measure: m, type: "default" },
+          compact ? 1 : 0
+        );
+    });
+  });
+}
+var init_hierarchy_first = __esm({
+  "xlsx/pivot/hierarchy-first.ts"() {
+    init_data();
+    init_measures();
+  }
+});
+
 // xlsx/pivot/hierarchy.ts
-function hierarchicalPivotGrid(pivot, 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 layout2 = pivot.layout ?? "tabular";
   const compact = layout2 === "compact";
-  const top = layout2 !== "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) && layout2 !== "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();
@@ -20109,20 +20358,12 @@ function hierarchicalPivotGrid(pivot, aggregate3) {
         collect(buckets, JSON.stringify([...key, column]), record);
     }
   }
-  const rows = details.size + rowItems.length * (Number(layout2 !== "tabular") + Number(bottom)) + 3;
-  if (rows * (columnItems.length + 3) > 1e6)
-    throw new Error("The PivotTable result is too large.");
+  const dimensions = pivotHeaderDimensions(pivot, columnItems.length, rowLabelColumns);
+  const rows = (details.size + rowItems.length * Number(bottom) + 1) * (rowsAxis ? measures.length : 1) + rowItems.length * Number(layout2 !== "tabular") * (firstValues ? measures.length : 1) + (firstValues ? measures.length : between ? rowItems.length * measures.length : details.size) * Number(rowsAxis && layout2 !== "tabular") + dimensions.rows;
+  if (rows * dimensions.width > 1e6) throw new Error("The PivotTable result is too large.");
   const labels = compact ? ["Row Labels"] : [pivot.rowField, pivot.secondRowField];
-  const values2 = pivot.columnField ? [
-    [
-      pivot.valueCaption,
-      ...compact ? [] : [null],
-      compact ? "Column Labels" : pivot.columnField,
-      ...columnItems.slice(1).map(() => null),
-      null
-    ],
-    [...labels, ...columnItems.map(label2), "Grand Total"]
-  ] : [[...labels, pivot.valueCaption]];
+  const values2 = pivotHeaders(pivot, columnItems, labels, label2);
+  const firstDataRow = values2.length;
   const indents = values2.map(() => 0);
   const rowEntries = [];
   const append = (labels2, numbers4, entry3, indent = 0) => {
@@ -20130,98 +20371,196 @@ 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 (layout2 !== "tabular")
-      append(
-        [label2(outer), ...compact ? [] : [null]],
-        top ? numbers3([key], groups.get(key) ?? []) : Array(columnItems.length + 1).fill(null),
-        { indices: [outerIndex] }
-      );
-    let first2 = true;
-    [...children2.get(key)].sort((a2, b) => innerIndices.get(a2) - innerIndices.get(b)).forEach((innerKey) => {
-      const innerIndex = innerIndices.get(innerKey);
-      const inner = secondRowItems[innerIndex];
-      const keys = [key, innerKey];
-      const records = details.get(JSON.stringify(keys));
-      if (!records) return;
-      append(
-        compact ? [label2(inner)] : [
-          pivot.repeatLabels || layout2 === "tabular" && first2 ? label2(outer) : null,
-          label2(inner)
+  const numbers3 = (keys, records) => bands(keys, records).flat();
+  const appendMeasures = (labels2, keys, records, indices, type) => {
+    const values3 = bands(keys, records);
+    measures.forEach(
+      (measure, m) => append(
+        type ? [
+          `${type === "grand" ? "Total" : String(labels2[0])} ${measure.caption}`,
+          ...Array(rowLabelColumns - 1).fill(null)
+        ] : compact ? [measure.caption] : [
+          ...labels2.map(
+            (label3) => layout2 === "tabular" && m === 0 || pivot.repeatLabels ? label3 : null
+          ),
+          measure.caption
         ],
-        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(label2(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 (layout2 !== "tabular")
+        append(
+          [label2(outer), ...Array(rowLabelColumns - 1).fill(null)],
+          top ? numbers3([key], groups.get(key) ?? []) : Array(dimensions.width - rowLabelColumns).fill(null),
+          { indices: [outerIndex] }
+        );
+      let first2 = true;
+      const innerKeys = [...children2.get(key)].sort(
+        (a2, b) => innerIndices.get(a2) - innerIndices.get(b)
       );
-    }
-  });
-  append(["Grand Total", ...compact ? [] : [null]], numbers3([], pivot.records), {
-    indices: [0],
-    type: "grand"
-  });
+      if (between)
+        measures.forEach((measure, m) => {
+          if (layout2 !== "tabular")
+            append(
+              compact ? [measure.caption] : [pivot.repeatLabels ? label2(outer) : null, measure.caption, null],
+              Array(dimensions.width - rowLabelColumns).fill(null),
+              { indices: [outerIndex, m], measure: m },
+              compact ? 1 : 0
+            );
+          innerKeys.forEach((innerKey, child3) => {
+            const innerIndex = innerIndices.get(innerKey);
+            const keys = [key, innerKey];
+            const records = details.get(JSON.stringify(keys));
+            append(
+              compact ? [label2(secondRowItems[innerIndex])] : [
+                pivot.repeatLabels || layout2 === "tabular" && m === 0 && child3 === 0 ? label2(outer) : null,
+                layout2 === "tabular" && child3 === 0 ? measure.caption : null,
+                label2(secondRowItems[innerIndex])
+              ],
+              [
+                ...columnItems.map(
+                  (column) => pivotMeasureNumber(
+                    pivot,
+                    buckets.get(JSON.stringify([...keys, pivotValueKey(column)])) ?? [],
+                    measure
+                  )
+                ),
+                pivotMeasureNumber(pivot, records, measure)
+              ],
+              { indices: [outerIndex, m, innerIndex], measure: m },
+              compact ? 2 : 0
+            );
+          });
+        });
+      else
+        innerKeys.forEach((innerKey) => {
+          const innerIndex = innerIndices.get(innerKey);
+          const inner = secondRowItems[innerIndex];
+          const keys = [key, innerKey];
+          const records = details.get(JSON.stringify(keys));
+          if (!records) return;
+          if (rowsAxis) {
+            if (layout2 !== "tabular")
+              append(
+                compact ? [label2(inner)] : [pivot.repeatLabels ? label2(outer) : null, label2(inner), null],
+                Array(dimensions.width - rowLabelColumns).fill(null),
+                { indices: [outerIndex, innerIndex] },
+                compact ? 1 : 0
+              );
+            appendMeasures(
+              [pivot.repeatLabels || first2 ? label2(outer) : null, label2(inner)],
+              keys,
+              records,
+              [outerIndex, innerIndex]
+            );
+            first2 = false;
+            return;
+          }
+          append(
+            compact ? [label2(inner)] : [
+              pivot.repeatLabels || layout2 === "tabular" && first2 ? label2(outer) : null,
+              label2(inner)
+            ],
+            numbers3(keys, records),
+            { indices: [outerIndex, innerIndex] },
+            compact ? 1 : 0
+          );
+          first2 = false;
+        });
+      if (bottom) {
+        if (rowsAxis) {
+          appendMeasures([label2(outer)], [key], groups.get(key) ?? [], [outerIndex], "default");
+          return;
+        }
+        const caption = String(label2(outer));
+        append(
+          [`${caption} Total`, ...compact ? [] : [null]],
+          numbers3([key], groups.get(key) ?? []),
+          { indices: [outerIndex], type: "default" }
+        );
+      }
+    });
+  if (rowsAxis) appendMeasures([], [], pivot.records, [0], "grand");
+  else
+    append(["Grand Total", ...compact ? [] : [null]], numbers3([], pivot.records), {
+      indices: [0],
+      type: "grand"
+    });
   return {
     values: values2,
     rowItems,
     secondRowItems,
     columnItems,
     rowEntries,
-    firstDataRow: pivot.columnField ? 2 : 1,
+    firstDataRow,
     rowLabelColumns,
-    indents
+    indents,
+    ...rowsAxis ? { firstHeaderRow: 1 } : {}
   };
 }
 var label2;
 var init_hierarchy2 = __esm({
   "xlsx/pivot/hierarchy.ts"() {
     init_data();
+    init_hierarchy_first();
+    init_measures();
     label2 = pivotItemLabel;
   }
 });
 
 // xlsx/pivot/aggregate.ts
-function aggregate2(records, field, type) {
-  if (!records.length) return null;
-  const values2 = records.map((record) => record[field] ?? null);
-  if (type === "count") return values2.filter((value) => value !== null && value !== "").length;
-  const error = values2.find(isCellError);
-  if (error) return error;
-  const numbers3 = values2.filter((value) => typeof value === "number");
-  if (!numbers3.length) return type === "average" ? { error: "#DIV/0!" } : 0;
-  if (type === "min") return numbers3.reduce((a2, b) => Math.min(a2, b));
-  if (type === "max") return numbers3.reduce((a2, b) => Math.max(a2, b));
-  const sum2 = numbers3.reduce((total2, value) => total2 + value, 0);
-  return type === "average" ? sum2 / numbers3.length : sum2;
-}
 function pivotGrid(pivot) {
   validatePivotFields(pivot);
-  if (pivot.secondRowField) return hierarchicalPivotGrid(pivot, aggregate2);
+  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 cells2 = /* @__PURE__ */ new Map();
   const columns = /* @__PURE__ */ new Map();
@@ -20239,48 +20578,130 @@ function pivotGrid(pivot) {
       collect(cells2, JSON.stringify([key, col]), record);
     }
   }
-  const label3 = pivotItemLabel;
-  const values2 = pivot.columnField ? [
-    [
-      pivot.valueCaption,
-      pivot.layout === "compact" ? "Column Labels" : pivot.columnField,
-      ...columnItems.slice(1).map(() => null),
-      null
-    ],
-    [
-      pivot.layout === "compact" ? "Row Labels" : pivot.rowField,
-      ...columnItems.map(label3),
-      "Grand Total"
-    ]
-  ] : [[pivot.layout === "compact" ? "Row Labels" : pivot.rowField, pivot.valueCaption]];
+  const firstDataRow = values2.length;
+  if (rowsAxis) {
+    const measures = pivotMeasures(pivot);
+    const rowEntries = [];
+    const indents = values2.map(() => 0);
+    const append = (caption, bands, index2, grand = false) => {
+      measures.forEach((measure, m) => {
+        values2.push([
+          ...compact ? [grand ? `Total ${measure.caption}` : measure.caption] : [
+            grand ? `Total ${measure.caption}` : pivot.repeatLabels || !headings && m === 0 ? caption : null,
+            grand ? null : measure.caption
+          ],
+          ...bands.map((band) => band[m] ?? null)
+        ]);
+        indents.push(compact && !grand ? 1 : 0);
+        rowEntries.push({
+          indices: grand ? [0] : [index2, m],
+          measure: m,
+          ...grand ? { type: "grand" } : {}
+        });
+      });
+    };
+    rowItems.forEach((item, index2) => {
+      const key = pivotValueKey(item);
+      if (headings) {
+        values2.push([label3(item), ...Array(dimensions.width - 1).fill(null)]);
+        rowEntries.push({ indices: [index2] });
+        indents.push(0);
+      }
+      append(
+        label3(item),
+        [
+          ...columnItems.map(
+            (col) => pivotNumbers(pivot, cells2.get(JSON.stringify([key, pivotValueKey(col)])) ?? [])
+          ),
+          pivotNumbers(pivot, groups.get(key) ?? [])
+        ],
+        index2
+      );
+    });
+    append(
+      "Grand Total",
+      [
+        ...columnItems.map((col) => pivotNumbers(pivot, columns.get(pivotValueKey(col)) ?? [])),
+        pivotNumbers(pivot, pivot.records)
+      ],
+      0,
+      true
+    );
+    return {
+      values: values2,
+      rowItems,
+      columnItems,
+      firstDataRow,
+      rowLabelColumns: compact ? 1 : 2,
+      indents,
+      firstHeaderRow: 1,
+      rowEntries
+    };
+  }
   for (const row2 of rowItems) {
     const records = groups.get(pivotValueKey(row2)) ?? [];
     values2.push([
       label3(row2),
-      ...columnItems.map(
-        (col) => aggregate2(
-          cells2.get(JSON.stringify([pivotValueKey(row2), pivotValueKey(col)])) ?? [],
-          valueField,
-          pivot.aggregate
+      ...columnItems.flatMap(
+        (col) => pivotNumbers(
+          pivot,
+          cells2.get(JSON.stringify([pivotValueKey(row2), pivotValueKey(col)])) ?? []
         )
       ),
-      aggregate2(records, valueField, pivot.aggregate)
+      ...pivotNumbers(pivot, records)
     ]);
   }
   values2.push([
     "Grand Total",
-    ...columnItems.map(
-      (col) => aggregate2(columns.get(pivotValueKey(col)) ?? [], valueField, pivot.aggregate)
-    ),
-    aggregate2(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 };
 }
 var init_aggregate = __esm({
   "xlsx/pivot/aggregate.ts"() {
-    init_model();
     init_data();
+    init_page_filter();
     init_hierarchy2();
+    init_measures();
+  }
+});
+
+// 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 index2 = axes2[axis]?.[item];
+        if (index2 === void 0) throw new Error("Invalid report row axis item");
+        return index2;
+      })
+    }
+  );
+}
+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>`;
+}
+var init_values_axis = __esm({
+  "xlsx/pivot/values-axis.ts"() {
+    init_xml_out();
   }
 });
 
@@ -20289,45 +20710,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, index2) => [pivotValueKey(item), index2]));
+    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 value = 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 items2 = index2 === page ? pageItems : index2 === row2 ? rowItemsFull : index2 === second ? secondRowItemsFull : index2 === col ? columnItemsFull : void 0;
     const subtotal = !(index2 === row2 && pivot.subtotals === false);
     const repeated = pivot.repeatLabels && (index2 === row2 || index2 === second) ? '<extLst><ext uri="{2946ED86-A175-432a-8AC1-64E0C546D7DE}"><x14:pivotField xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" fillDownLabels="1"/></ext></extLst>' : "";
-    return `<pivotField${attrs({ axis: index2 === row2 || index2 === second ? "axisRow" : index2 === col ? "axisCol" : void 0, dataField: index2 === value ? true : void 0, compact, outline, showAll: false, subtotalTop: index2 === row2 ? top : void 0, defaultSubtotal: subtotal ? void 0 : false })}>${items2 ? `<items count="${items2.length + Number(subtotal)}">${items2.map((item) => `<item x="${cache2.indices[index2].get(pivotValueKey(item))}"/>`).join("")}${subtotal ? '<item t="default"/>' : ""}</items>` : ""}${repeated}</pivotField>`;
+    return `<pivotField${attrs({ axis: index2 === page ? "axisPage" : index2 === row2 || index2 === second ? "axisRow" : index2 === col ? "axisCol" : void 0, dataField: measures.some((measure) => pivot.fields.indexOf(measure.field) === index2) ? true : void 0, compact, outline, showAll: false, subtotalTop: index2 === row2 ? top : void 0, defaultSubtotal: subtotal ? void 0 : false })}>${items2 ? `<items count="${items2.length + Number(subtotal)}">${items2.map((item) => `<item x="${cache2.indices[index2].get(pivotValueKey(item))}"/>`).join("")}${subtotal ? '<item t="default"/>' : ""}</items>` : ""}${repeated}</pivotField>`;
   }).join("");
-  const items = (count2) => Array.from({ length: count2 }, (_v, i) => `<i><x v="${i}"/></i>`).join("") + '<i t="grand"><x/></i>';
-  const header = grid.firstDataRow - 1;
-  const rowIndices = [row2, ...second >= 0 ? [second] : []];
+  const items = (count2, indices) => Array.from({ length: count2 }, (_v, i) => `<i><x v="${indices?.[i] ?? i}"/></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: value, 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((index2) => `<x${attrs({ v: index2 || 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((index2) => `<field x="${index2}"/>`).join("")}</rowFields><rowItems count="${grid.rowEntries?.length ?? grid.rowItems.length + 1}">${rowItems}</rowItems>`;
+  if (multiple && !rowsAxis)
+    body += `<colFields count="${col >= 0 ? 2 : 1}">${col >= 0 ? `<field x="${col}"/>` : ""}<field x="-2"/></colFields>${pivotValueAxisItems(measures.length, col >= 0 ? grid.columnItems.length : void 0, 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(
@@ -20338,6 +20801,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");
   }
@@ -20348,7 +20812,8 @@ function pivotTableXml(pivot, cacheId, cache2) {
     "rowItems",
     "colFields",
     "colItems",
-    "dataFields"
+    "dataFields",
+    "pageFields"
   ]);
   for (const child3 of elements(root)) if (replaced.has(child3.localName)) root.removeChild(child3);
   const replacement = parseXml(`<root xmlns="${NS.x}">${body}</root>`).documentElement;
@@ -20359,10 +20824,13 @@ function pivotTableXml(pivot, cacheId, cache2) {
 var init_table_xml = __esm({
   "xlsx/pivot/table-xml.ts"() {
     init_xml2();
+    init_data();
     init_address();
     init_xml_out();
     init_aggregate();
     init_data();
+    init_measures();
+    init_values_axis();
   }
 });