@cj-tech-master/excelts 1.5.0 → 1.6.1

package/dist/browser/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
- * @cj-tech-master/excelts v1.5.0
+ * @cj-tech-master/excelts v1.6.1
  * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
  * (c) 2025 cjnoname
  * Released under the MIT License
@@ -1882,7 +1882,7 @@ var ExcelTS = (function(exports) {
 	* This includes header rows, widths, key, (style), etc.
 	* Worksheet will condense the columns as appropriate during serialization
 	*/
-	var Column = class Column {
+	var Column$1 = class Column$1 {
 		constructor(worksheet, number, defn) {
 			this._worksheet = worksheet;
 			this._number = number;
@@ -1930,13 +1930,17 @@ var ExcelTS = (function(exports) {
 				this.outlineLevel = 0;
 			}
 		}
+		/**
+		* Get header values as an array (for multi-row header support)
+		*/
 		get headers() {
 			if (Array.isArray(this._header)) return this._header;
 			if (this._header !== void 0) return [this._header];
 			return [];
 		}
 		/**
-		* Can be a string to set one row high header or an array to set multi-row high header
+		* Can be a single value or an array for multi-row headers.
+		* Supports any CellValue type including Date, number, string, etc.
 		*/
 		get header() {
 			return this._header;
@@ -1944,8 +1948,8 @@ var ExcelTS = (function(exports) {
 		set header(value) {
 			if (value !== void 0) {
 				this._header = value;
-				this.headers.forEach((text, index) => {
-					this._worksheet.getCell(index + 1, this.number).value = text;
+				this.headers.forEach((cellValue, index) => {
+					this._worksheet.getCell(index + 1, this.number).value = cellValue;
 				});
 			} else this._header = void 0;
 		}
@@ -2132,8 +2136,8 @@ var ExcelTS = (function(exports) {
 			});
 			while (index < cols.length) {
 				const col = cols[index++];
-				while (count < col.min) columns.push(new Column(worksheet, count++));
-				while (count <= col.max) columns.push(new Column(worksheet, count++, col));
+				while (count < col.min) columns.push(new Column$1(worksheet, count++));
+				while (count <= col.max) columns.push(new Column$1(worksheet, count++, col));
 			}
 			return columns.length ? columns : null;
 		}
@@ -2274,7 +2278,7 @@ var ExcelTS = (function(exports) {
 
 //#endregion
 //#region src/doc/table.ts
-	var Column$1 = class {
+	var Column = class {
 		constructor(table, column, index) {
 			this.table = table;
 			this.column = column;
@@ -2519,7 +2523,7 @@ var ExcelTS = (function(exports) {
 		}
 		getColumn(colIndex) {
 			const column = this.table.columns[colIndex];
-			return new Column$1(this, column, colIndex);
+			return new Column(this, column, colIndex);
 		}
 		addColumn(column, values, colIndex) {
 			this.cacheState();
@@ -13579,10 +13583,10 @@ var ExcelTS = (function(exports) {
 //#endregion
 //#region node_modules/.pnpm/buffer-xor@1.0.3/node_modules/buffer-xor/index.js
 	var require_buffer_xor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-		var import_buffer$13 = require_buffer$1();
+		var import_buffer$8 = require_buffer$1();
 		module.exports = function xor(a, b) {
 			var length = Math.min(a.length, b.length);
-			var buffer = new import_buffer$13.Buffer(length);
+			var buffer = new import_buffer$8.Buffer(length);
 			for (var i$1 = 0; i$1 < length; ++i$1) buffer[i$1] = a[i$1] ^ b[i$1];
 			return buffer;
 		};
@@ -13694,14 +13698,14 @@ var ExcelTS = (function(exports) {
 //#endregion
 //#region node_modules/.pnpm/browserify-aes@1.2.0/node_modules/browserify-aes/modes/ofb.js
 	var require_ofb = /* @__PURE__ */ __commonJSMin(((exports) => {
-		var import_buffer$12 = require_buffer$1();
+		var import_buffer$7 = require_buffer$1();
 		var xor = require_buffer_xor();
 		function getBlock(self$1) {
 			self$1._prev = self$1._cipher.encryptBlock(self$1._prev);
 			return self$1._prev;
 		}
 		exports.encrypt = function(self$1, chunk) {
-			while (self$1._cache.length < chunk.length) self$1._cache = import_buffer$12.Buffer.concat([self$1._cache, getBlock(self$1)]);
+			while (self$1._cache.length < chunk.length) self$1._cache = import_buffer$7.Buffer.concat([self$1._cache, getBlock(self$1)]);
 			var pad = self$1._cache.slice(0, chunk.length);
 			self$1._cache = self$1._cache.slice(chunk.length);
 			return xor(chunk, pad);
@@ -17411,7 +17415,7 @@ var ExcelTS = (function(exports) {
 //#endregion
 //#region node_modules/.pnpm/diffie-hellman@5.0.3/node_modules/diffie-hellman/lib/dh.js
 	var require_dh = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-		var import_buffer$11 = require_buffer$1();
+		var import_buffer$6 = require_buffer$1();
 		var BN = require_bn$1();
 		var millerRabin = new (require_mr())();
 		var TWENTYFOUR = new BN(24);
@@ -17424,13 +17428,13 @@ var ExcelTS = (function(exports) {
 		module.exports = DH;
 		function setPublicKey(pub, enc) {
 			enc = enc || "utf8";
-			if (!import_buffer$11.Buffer.isBuffer(pub)) pub = new import_buffer$11.Buffer(pub, enc);
+			if (!import_buffer$6.Buffer.isBuffer(pub)) pub = new import_buffer$6.Buffer(pub, enc);
 			this._pub = new BN(pub);
 			return this;
 		}
 		function setPrivateKey(priv, enc) {
 			enc = enc || "utf8";
-			if (!import_buffer$11.Buffer.isBuffer(priv)) priv = new import_buffer$11.Buffer(priv, enc);
+			if (!import_buffer$6.Buffer.isBuffer(priv)) priv = new import_buffer$6.Buffer(priv, enc);
 			this._priv = new BN(priv);
 			return this;
 		}
@@ -17490,12 +17494,12 @@ var ExcelTS = (function(exports) {
 		DH.prototype.computeSecret = function(other) {
 			other = new BN(other);
 			other = other.toRed(this._prime);
-			var out = new import_buffer$11.Buffer(other.redPow(this._priv).fromRed().toArray());
+			var out = new import_buffer$6.Buffer(other.redPow(this._priv).fromRed().toArray());
 			var prime = this.getPrime();
 			if (out.length < prime.length) {
-				var front = new import_buffer$11.Buffer(prime.length - out.length);
+				var front = new import_buffer$6.Buffer(prime.length - out.length);
 				front.fill(0);
-				out = import_buffer$11.Buffer.concat([front, out]);
+				out = import_buffer$6.Buffer.concat([front, out]);
 			}
 			return out;
 		};
@@ -17513,13 +17517,13 @@ var ExcelTS = (function(exports) {
 		};
 		DH.prototype.setGenerator = function(gen, enc) {
 			enc = enc || "utf8";
-			if (!import_buffer$11.Buffer.isBuffer(gen)) gen = new import_buffer$11.Buffer(gen, enc);
+			if (!import_buffer$6.Buffer.isBuffer(gen)) gen = new import_buffer$6.Buffer(gen, enc);
 			this.__gen = gen;
 			this._gen = new BN(gen);
 			return this;
 		};
 		function formatReturnValue(bn, enc) {
-			var buf = new import_buffer$11.Buffer(bn.toArray());
+			var buf = new import_buffer$6.Buffer(bn.toArray());
 			if (!enc) return buf;
 			else return buf.toString(enc);
 		}
@@ -17528,12 +17532,12 @@ var ExcelTS = (function(exports) {
 //#endregion
 //#region node_modules/.pnpm/diffie-hellman@5.0.3/node_modules/diffie-hellman/browser.js
 	var require_browser$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
-		var import_buffer$10 = require_buffer$1();
+		var import_buffer$5 = require_buffer$1();
 		var generatePrime = require_generatePrime();
 		var primes = require_primes();
 		var DH = require_dh();
 		function getDiffieHellman(mod) {
-			return new DH(new import_buffer$10.Buffer(primes[mod].prime, "hex"), new import_buffer$10.Buffer(primes[mod].gen, "hex"));
+			return new DH(new import_buffer$5.Buffer(primes[mod].prime, "hex"), new import_buffer$5.Buffer(primes[mod].gen, "hex"));
 		}
 		var ENCODINGS = {
 			"binary": true,
@@ -17541,13 +17545,13 @@ var ExcelTS = (function(exports) {
 			"base64": true
 		};
 		function createDiffieHellman(prime, enc, generator, genc) {
-			if (import_buffer$10.Buffer.isBuffer(enc) || ENCODINGS[enc] === void 0) return createDiffieHellman(prime, "binary", enc, generator);
+			if (import_buffer$5.Buffer.isBuffer(enc) || ENCODINGS[enc] === void 0) return createDiffieHellman(prime, "binary", enc, generator);
 			enc = enc || "binary";
 			genc = genc || "binary";
-			generator = generator || new import_buffer$10.Buffer([2]);
-			if (!import_buffer$10.Buffer.isBuffer(generator)) generator = new import_buffer$10.Buffer(generator, genc);
+			generator = generator || new import_buffer$5.Buffer([2]);
+			if (!import_buffer$5.Buffer.isBuffer(generator)) generator = new import_buffer$5.Buffer(generator, genc);
 			if (typeof prime === "number") return new DH(generatePrime(prime, generator), generator, true);
-			if (!import_buffer$10.Buffer.isBuffer(prime)) prime = new import_buffer$10.Buffer(prime, enc);
+			if (!import_buffer$5.Buffer.isBuffer(prime)) prime = new import_buffer$5.Buffer(prime, enc);
 			return new DH(prime, generator, true);
 		}
 		exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman;
@@ -25839,7 +25843,7 @@ var ExcelTS = (function(exports) {
 //#endregion
 //#region node_modules/.pnpm/create-ecdh@4.0.4/node_modules/create-ecdh/browser.js
 	var require_browser$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-		var import_buffer$9 = require_buffer$1();
+		var import_buffer$4 = require_buffer$1();
 		var elliptic = require_elliptic();
 		var BN = require_bn$1();
 		module.exports = function createECDH(curve) {
@@ -25892,7 +25896,7 @@ var ExcelTS = (function(exports) {
 		};
 		ECDH.prototype.computeSecret = function(other, inenc, enc) {
 			inenc = inenc || "utf8";
-			if (!import_buffer$9.Buffer.isBuffer(other)) other = new import_buffer$9.Buffer(other, inenc);
+			if (!import_buffer$4.Buffer.isBuffer(other)) other = new import_buffer$4.Buffer(other, inenc);
 			return formatReturnValue(this.curve.keyFromPublic(other).getPublic().mul(this.keys.getPrivate()).getX(), enc, this.curveType.byteLength);
 		};
 		ECDH.prototype.getPublicKey = function(enc, format$2) {
@@ -25906,13 +25910,13 @@ var ExcelTS = (function(exports) {
 		};
 		ECDH.prototype.setPublicKey = function(pub, enc) {
 			enc = enc || "utf8";
-			if (!import_buffer$9.Buffer.isBuffer(pub)) pub = new import_buffer$9.Buffer(pub, enc);
+			if (!import_buffer$4.Buffer.isBuffer(pub)) pub = new import_buffer$4.Buffer(pub, enc);
 			this.keys._importPublic(pub);
 			return this;
 		};
 		ECDH.prototype.setPrivateKey = function(priv, enc) {
 			enc = enc || "utf8";
-			if (!import_buffer$9.Buffer.isBuffer(priv)) priv = new import_buffer$9.Buffer(priv, enc);
+			if (!import_buffer$4.Buffer.isBuffer(priv)) priv = new import_buffer$4.Buffer(priv, enc);
 			var _priv = new BN(priv);
 			_priv = _priv.toString(16);
 			this.keys = this.curve.genKeyPair();
@@ -25921,11 +25925,11 @@ var ExcelTS = (function(exports) {
 		};
 		function formatReturnValue(bn, enc, len) {
 			if (!Array.isArray(bn)) bn = bn.toArray();
-			var buf = new import_buffer$9.Buffer(bn);
+			var buf = new import_buffer$4.Buffer(bn);
 			if (len && buf.length < len) {
-				var zeros = new import_buffer$9.Buffer(len - buf.length);
+				var zeros = new import_buffer$4.Buffer(len - buf.length);
 				zeros.fill(0);
-				buf = import_buffer$9.Buffer.concat([zeros, buf]);
+				buf = import_buffer$4.Buffer.concat([zeros, buf]);
 			}
 			if (!enc) return buf;
 			else return buf.toString(enc);
@@ -26300,21 +26304,21 @@ var ExcelTS = (function(exports) {
 
 //#endregion
 //#region src/utils/encryptor.ts
-	var import_buffer$8 = require_buffer$1();
+	var import_buffer$3 = require_buffer$1();
 	var import_crypto_browserify = /* @__PURE__ */ __toESM(require_crypto_browserify(), 1);
 	const Encryptor = {
 		hash(algorithm, ...buffers) {
 			const hash = import_crypto_browserify.createHash(algorithm);
-			hash.update(import_buffer$8.Buffer.concat(buffers));
+			hash.update(import_buffer$3.Buffer.concat(buffers));
 			return hash.digest();
 		},
 		convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
 			hashAlgorithm = hashAlgorithm.toLowerCase();
 			if (import_crypto_browserify.getHashes().indexOf(hashAlgorithm) < 0) throw new Error(`Hash algorithm '${hashAlgorithm}' not supported!`);
-			const passwordBuffer = import_buffer$8.Buffer.from(password, "utf16le");
-			let key = this.hash(hashAlgorithm, import_buffer$8.Buffer.from(saltValue, "base64"), passwordBuffer);
+			const passwordBuffer = import_buffer$3.Buffer.from(password, "utf16le");
+			let key = this.hash(hashAlgorithm, import_buffer$3.Buffer.from(saltValue, "base64"), passwordBuffer);
 			for (let i$1 = 0; i$1 < spinCount; i$1++) {
-				const iterator = import_buffer$8.Buffer.alloc(4);
+				const iterator = import_buffer$3.Buffer.alloc(4);
 				iterator.writeUInt32LE(i$1, 0);
 				key = this.hash(hashAlgorithm, key, iterator);
 			}
@@ -26451,12 +26455,6 @@ var ExcelTS = (function(exports) {
 		}
 		return result.sort();
 	}
-	function objectFromProps(props, value = null) {
-		return props.reduce((result, property) => {
-			result[property] = value;
-			return result;
-		}, {});
-	}
 	const textDecoder = new TextDecoder("utf-8");
 	/**
 	* Convert a Buffer or ArrayBuffer to a UTF-8 string
@@ -26469,49 +26467,117 @@ var ExcelTS = (function(exports) {
 
 //#endregion
 //#region src/doc/pivot-table.ts
+/**
+	* Creates a PivotTableSource adapter from a Table object.
+	* This allows Tables to be used as pivot table data sources with the same interface as Worksheets.
+	*/
+	function createTableSourceAdapter(table) {
+		const tableModel = table.model;
+		if (tableModel.headerRow === false) throw new Error("Cannot create pivot table from a table without headers. Set headerRow: true on the table.");
+		if (!tableModel.rows || tableModel.rows.length === 0) throw new Error("Cannot create pivot table from an empty table. Add data rows to the table.");
+		const columnNames = tableModel.columns.map((col) => col.name);
+		const nameSet = /* @__PURE__ */ new Set();
+		for (const name of columnNames) {
+			if (nameSet.has(name)) throw new Error(`Duplicate column name "${name}" found in table. Pivot tables require unique column names.`);
+			nameSet.add(name);
+		}
+		const headerRow = [void 0, ...columnNames];
+		const dataRows = tableModel.rows.map((row) => [void 0, ...row]);
+		const tl = tableModel.tl;
+		const startRow = tl.row;
+		const startCol = tl.col;
+		const endRow = startRow + tableModel.rows.length;
+		const endCol = startCol + columnNames.length - 1;
+		const shortRange = colCache.encode(startRow, startCol, endRow, endCol);
+		return {
+			name: tableModel.name,
+			getRow(rowNumber) {
+				if (rowNumber === 1) return { values: headerRow };
+				const dataIndex = rowNumber - 2;
+				if (dataIndex >= 0 && dataIndex < dataRows.length) return { values: dataRows[dataIndex] };
+				return { values: [] };
+			},
+			getColumn(columnNumber) {
+				if (columnNumber < 1 || columnNumber > columnNames.length) return { values: [] };
+				const values = [];
+				values[1] = columnNames[columnNumber - 1];
+				for (let i$1 = 0; i$1 < tableModel.rows.length; i$1++) values[i$1 + 2] = tableModel.rows[i$1][columnNumber - 1];
+				return { values };
+			},
+			getSheetValues() {
+				const result = [];
+				result[1] = headerRow;
+				for (let i$1 = 0; i$1 < dataRows.length; i$1++) result[i$1 + 2] = dataRows[i$1];
+				return result;
+			},
+			dimensions: { shortRange }
+		};
+	}
+	/**
+	* Resolves the data source from the model, supporting both sourceSheet and sourceTable.
+	*/
+	function resolveSource(model) {
+		if (model.sourceTable) return createTableSourceAdapter(model.sourceTable);
+		return model.sourceSheet;
+	}
 	function makePivotTable(worksheet, model) {
-		validate(worksheet, model);
-		const { sourceSheet } = model;
-		const { rows, columns, values } = model;
-		const cacheFields = makeCacheFields(sourceSheet, [...rows, ...columns]);
+		if (!model.sourceSheet && !model.sourceTable) throw new Error("Either sourceSheet or sourceTable must be provided.");
+		if (model.sourceSheet && model.sourceTable) throw new Error("Cannot specify both sourceSheet and sourceTable. Choose one.");
+		const source = resolveSource(model);
+		validate(worksheet, model, source);
+		const { rows, values } = model;
+		const columns = model.columns ?? [];
+		const cacheFields = makeCacheFields(source, [...rows, ...columns]);
 		const nameToIndex = cacheFields.reduce((result, cacheField, index) => {
 			result[cacheField.name] = index;
 			return result;
 		}, {});
+		const rowIndices = rows.map((row) => nameToIndex[row]);
+		const columnIndices = columns.map((column) => nameToIndex[column]);
+		const valueIndices = values.map((value) => nameToIndex[value]);
+		const tableNumber = worksheet.workbook.pivotTables.length + 1;
 		return {
-			sourceSheet,
-			rows: rows.map((row) => nameToIndex[row]),
-			columns: columns.map((column) => nameToIndex[column]),
-			values: values.map((value) => nameToIndex[value]),
-			metric: "sum",
+			source,
+			rows: rowIndices,
+			columns: columnIndices,
+			values: valueIndices,
+			metric: model.metric ?? "sum",
 			cacheFields,
-			cacheId: "10"
+			cacheId: String(10 + tableNumber - 1),
+			applyWidthHeightFormats: model.applyWidthHeightFormats ?? "1",
+			tableNumber
 		};
 	}
-	function validate(worksheet, model) {
-		if (worksheet.workbook.pivotTables.length === 1) throw new Error("A pivot table was already added. At this time, ExcelTS supports at most one pivot table per file.");
-		if (model.metric && model.metric !== "sum") throw new Error("Only the \"sum\" metric is supported at this time.");
-		const isInHeaderNames = objectFromProps(model.sourceSheet.getRow(1).values.slice(1), true);
+	function validate(_worksheet, model, source) {
+		if (model.metric && model.metric !== "sum" && model.metric !== "count") throw new Error("Only the \"sum\" and \"count\" metrics are supported at this time.");
+		const columns = model.columns ?? [];
+		const headerNames = source.getRow(1).values.slice(1);
+		const headerNameSet = new Set(headerNames);
 		for (const name of [
 			...model.rows,
-			...model.columns,
+			...columns,
 			...model.values
-		]) if (!isInHeaderNames[name]) throw new Error(`The header name "${name}" was not found in ${model.sourceSheet.name}.`);
+		]) if (!headerNameSet.has(name)) throw new Error(`The header name "${name}" was not found in ${source.name}.`);
 		if (!model.rows.length) throw new Error("No pivot table rows specified.");
-		if (!model.columns.length) throw new Error("No pivot table columns specified.");
-		if (model.values.length !== 1) throw new Error("Exactly 1 value needs to be specified at this time.");
+		if (model.values.length < 1) throw new Error("Must have at least one value.");
+		if (model.values.length > 1 && columns.length > 0) throw new Error("It is currently not possible to have multiple values when columns are specified. Please either supply an empty array for columns or a single value.");
 	}
-	function makeCacheFields(worksheet, fieldNamesWithSharedItems) {
-		const names = worksheet.getRow(1).values;
-		const nameToHasSharedItems = objectFromProps(fieldNamesWithSharedItems, true);
+	function makeCacheFields(source, fieldNamesWithSharedItems) {
+		const names = source.getRow(1).values;
+		const sharedItemsFields = new Set(fieldNamesWithSharedItems);
 		const aggregate = (columnIndex) => {
-			const columnValues = worksheet.getColumn(columnIndex).values.splice(2);
-			return toSortedArray(new Set(columnValues));
+			const columnValues = source.getColumn(columnIndex).values;
+			const uniqueValues = /* @__PURE__ */ new Set();
+			for (let i$1 = 2; i$1 < columnValues.length; i$1++) {
+				const v = columnValues[i$1];
+				if (v !== null && v !== void 0) uniqueValues.add(v);
+			}
+			return toSortedArray(uniqueValues);
 		};
 		const result = [];
 		for (const columnIndex of range(1, names.length)) {
 			const name = names[columnIndex];
-			const sharedItems = nameToHasSharedItems[name] ? aggregate(columnIndex) : null;
+			const sharedItems = sharedItemsFields.has(name) ? aggregate(columnIndex) : null;
 			result.push({
 				name,
 				sharedItems
@@ -26692,7 +26758,7 @@ var ExcelTS = (function(exports) {
 			let count = 1;
 			const columns = this._columns = [];
 			value.forEach((defn) => {
-				const column = new Column(this, count++, false);
+				const column = new Column$1(this, count++, false);
 				columns.push(column);
 				column.defn = defn;
 			});
@@ -26722,7 +26788,7 @@ var ExcelTS = (function(exports) {
 			if (!this._columns) this._columns = [];
 			if (colNum > this._columns.length) {
 				let n = this._columns.length + 1;
-				while (n <= colNum) this._columns.push(new Column(this, n++));
+				while (n <= colNum) this._columns.push(new Column$1(this, n++));
 			}
 			return this._columns[colNum - 1];
 		}
@@ -27170,8 +27236,6 @@ var ExcelTS = (function(exports) {
 			return Object.values(this.tables);
 		}
 		addPivotTable(model) {
-			console.warn(`Warning: Pivot Table support is experimental. 
-Please leave feedback at https://github.com/excelts/excelts/discussions/2575`);
 			const pivotTable = makePivotTable(this, model);
 			this.pivotTables.push(pivotTable);
 			this.workbook.pivotTables.push(pivotTable);
@@ -27209,7 +27273,7 @@ Please leave feedback at https://github.com/excelts/excelts/discussions/2575`);
 				pivotTables: this.pivotTables,
 				conditionalFormattings: this.conditionalFormattings
 			};
-			model.cols = Column.toModel(this.columns || []);
+			model.cols = Column$1.toModel(this.columns || []);
 			const rows = model.rows = [];
 			const dimensions = model.dimensions = new Range();
 			this._rows.forEach((row) => {
@@ -27240,7 +27304,7 @@ Please leave feedback at https://github.com/excelts/excelts/discussions/2575`);
 		}
 		set model(value) {
 			this.name = value.name;
-			this._columns = Column.fromModel(this, value.cols);
+			this._columns = Column$1.fromModel(this, value.cols);
 			this._parseRows(value);
 			this._parseMergeCells(value);
 			this.dataValidations = new DataValidations(value.dataValidations);
@@ -33085,7 +33149,7 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 //#endregion
 //#region node_modules/.pnpm/browserify-zlib@0.2.0/node_modules/browserify-zlib/lib/binding.js
 	var require_binding = /* @__PURE__ */ __commonJSMin(((exports) => {
-		var import_buffer$7 = require_buffer$1();
+		var import_buffer$2 = require_buffer$1();
 		init_process();
 		var assert = require_assert();
 		var Zstream = require_zstream();
@@ -33151,7 +33215,7 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 			this.write_in_progress = true;
 			if (flush !== exports.Z_NO_FLUSH && flush !== exports.Z_PARTIAL_FLUSH && flush !== exports.Z_SYNC_FLUSH && flush !== exports.Z_FULL_FLUSH && flush !== exports.Z_FINISH && flush !== exports.Z_BLOCK) throw new Error("Invalid flush value");
 			if (input == null) {
-				input = import_buffer$7.Buffer.alloc(0);
+				input = import_buffer$2.Buffer.alloc(0);
 				in_len = 0;
 				in_off = 0;
 			}
@@ -33759,7 +33823,7 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 
 //#endregion
 //#region src/utils/zip/crc32.ts
-var import_stream_browserify$1 = require_stream_browserify();
+var import_stream_browserify = require_stream_browserify();
 var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 	init_process();
 	const isNode$1 = typeof api !== "undefined" && api.versions?.node;
@@ -33815,7 +33879,6 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 
 //#endregion
 //#region src/utils/zip/compress.ts
-	var import_buffer$6 = require_buffer$1();
 	init_process();
 	const isNode = typeof api !== "undefined" && api.versions?.node;
 	let _zlib = null;
@@ -33865,7 +33928,7 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 		if (level === 0) return data;
 		const zlib = await ensureZlib();
 		if (zlib && typeof zlib.deflateRawSync === "function") {
-			const result = zlib.deflateRawSync(import_buffer$6.Buffer.from(data), { level });
+			const result = zlib.deflateRawSync(import_buffer$3.Buffer.from(data), { level });
 			return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
 		}
 		if (typeof CompressionStream !== "undefined") return compressWithCompressionStream(data);
@@ -33886,7 +33949,7 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 		if (level === 0) return data;
 		const zlib = getZlib();
 		if (!zlib || typeof zlib.deflateRawSync !== "function") throw new Error("Synchronous compression is only available in Node.js environment");
-		const result = zlib.deflateRawSync(import_buffer$6.Buffer.from(data), { level });
+		const result = zlib.deflateRawSync(import_buffer$3.Buffer.from(data), { level });
 		return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
 	}
 	/**
@@ -34131,10 +34194,9 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 
 //#endregion
 //#region src/utils/string-buf.ts
-	var import_buffer$5 = require_buffer$1();
 	var StringBuf = class {
 		constructor(options) {
-			this._buf = import_buffer$5.Buffer.alloc(options && options.size || 16384);
+			this._buf = import_buffer$3.Buffer.alloc(options && options.size || 16384);
 			this._encoding = options && options.encoding || "utf8";
 			this._inPos = 0;
 			this._buffer = void 0;
@@ -34150,7 +34212,7 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 		}
 		toBuffer() {
 			if (!this._buffer) {
-				this._buffer = import_buffer$5.Buffer.alloc(this.length);
+				this._buffer = import_buffer$3.Buffer.alloc(this.length);
 				this._buf.copy(this._buffer, 0, 0, this.length);
 			}
 			return this._buffer;
@@ -34163,7 +34225,7 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 		_grow(min) {
 			let size = this._buf.length * 2;
 			while (size < min) size *= 2;
-			const buf = import_buffer$5.Buffer.alloc(size);
+			const buf = import_buffer$3.Buffer.alloc(size);
 			this._buf.copy(buf, 0);
 			this._buf = buf;
 		}
@@ -34188,7 +34250,6 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 
 //#endregion
 //#region src/utils/stream-buf.ts
-	var import_buffer$4 = require_buffer$1();
 	var StringChunk = class {
 		constructor(data, encoding) {
 			this._data = data;
@@ -34201,7 +34262,7 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 			return this.toBuffer().copy(target, targetOffset, offset, length);
 		}
 		toBuffer() {
-			if (!this._buffer) this._buffer = import_buffer$4.Buffer.from(this._data, this._encoding);
+			if (!this._buffer) this._buffer = import_buffer$3.Buffer.from(this._data, this._encoding);
 			return this._buffer;
 		}
 	};
@@ -34236,13 +34297,13 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 	var ReadWriteBuf = class {
 		constructor(size) {
 			this.size = size;
-			this.buffer = import_buffer$4.Buffer.alloc(size);
+			this.buffer = import_buffer$3.Buffer.alloc(size);
 			this.iRead = 0;
 			this.iWrite = 0;
 		}
 		toBuffer() {
 			if (this.iRead === 0 && this.iWrite === this.size) return this.buffer;
-			const buf = import_buffer$4.Buffer.alloc(this.iWrite - this.iRead);
+			const buf = import_buffer$3.Buffer.alloc(this.iWrite - this.iRead);
 			this.buffer.copy(buf, 0, this.iRead, this.iWrite);
 			return buf;
 		}
@@ -34263,7 +34324,7 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 				this.iRead = this.iWrite;
 				return buf;
 			}
-			buf = import_buffer$4.Buffer.alloc(size);
+			buf = import_buffer$3.Buffer.alloc(size);
 			this.buffer.copy(buf, 0, this.iRead, size);
 			this.iRead += size;
 			return buf;
@@ -34277,7 +34338,7 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 	};
 	const StreamBuf = function(options) {
 		if (!(this instanceof StreamBuf)) return new StreamBuf(options);
-		import_stream_browserify$1.Duplex.call(this, options);
+		import_stream_browserify.Duplex.call(this, options);
 		options = options || {};
 		this.bufSize = options.bufSize || 1024 * 1024;
 		this.buffers = [];
@@ -34289,12 +34350,12 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 		this.paused = false;
 		this.encoding = null;
 	};
-	inherits(StreamBuf, import_stream_browserify$1.Duplex, {
+	inherits(StreamBuf, import_stream_browserify.Duplex, {
 		toBuffer() {
 			switch (this.buffers.length) {
 				case 0: return null;
 				case 1: return this.buffers[0].toBuffer();
-				default: return import_buffer$4.Buffer.concat(this.buffers.map((rwBuf) => rwBuf.toBuffer()));
+				default: return import_buffer$3.Buffer.concat(this.buffers.map((rwBuf) => rwBuf.toBuffer()));
 			}
 		},
 		_getWritableBuffer() {
@@ -34332,9 +34393,9 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 			callback = callback || nop;
 			let chunk;
 			if (data instanceof StringBuf || data && data.constructor?.name === "StringBuf") chunk = new StringBufChunk(data);
-			else if (import_buffer$4.Buffer.isBuffer(data)) chunk = new BufferChunk(data);
-			else if (ArrayBuffer.isView(data)) chunk = new BufferChunk(import_buffer$4.Buffer.from(data.buffer, data.byteOffset, data.byteLength));
-			else if (data instanceof ArrayBuffer) chunk = new BufferChunk(import_buffer$4.Buffer.from(data));
+			else if (import_buffer$3.Buffer.isBuffer(data)) chunk = new BufferChunk(data);
+			else if (ArrayBuffer.isView(data)) chunk = new BufferChunk(import_buffer$3.Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+			else if (data instanceof ArrayBuffer) chunk = new BufferChunk(import_buffer$3.Buffer.from(data));
 			else if (typeof data === "string" || data instanceof String) chunk = new StringChunk(String(data), encoding);
 			else throw new Error("Chunk must be one of type String, Buffer, Uint8Array, ArrayBuffer or StringBuf.");
 			if (this.pipes.length) if (this.batch) {
@@ -34389,11 +34450,11 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 					buffers.push(buffer);
 					if (first.eod && first.full) this.buffers.shift();
 				}
-				return import_buffer$4.Buffer.concat(buffers);
+				return import_buffer$3.Buffer.concat(buffers);
 			}
 			buffers = this.buffers.map((buf) => buf.toBuffer()).filter(Boolean);
 			this.buffers = [];
-			return import_buffer$4.Buffer.concat(buffers);
+			return import_buffer$3.Buffer.concat(buffers);
 		},
 		setEncoding(encoding) {
 			this.encoding = encoding;
@@ -34425,7 +34486,6 @@ var import_events = /* @__PURE__ */ __toESM(require_events(), 1);
 
 //#endregion
 //#region src/utils/zip-stream.ts
-	var import_buffer$3 = require_buffer$1();
 	var ZipWriter = class extends import_events.default.EventEmitter {
 		constructor(options) {
 			super();
@@ -38998,27 +39058,28 @@ ${XMLNS_NAMESPACE}.`);
 				PartName: "/xl/workbook.xml",
 				ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"
 			});
-			model.worksheets.forEach((worksheet) => {
-				const name = `/xl/worksheets/sheet${worksheet.id}.xml`;
+			model.worksheets.forEach((worksheet, index) => {
+				const name = `/xl/worksheets/sheet${worksheet.fileIndex || index + 1}.xml`;
 				xmlStream.leafNode("Override", {
 					PartName: name,
 					ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"
 				});
 			});
-			if ((model.pivotTables || []).length) {
+			if ((model.pivotTables || []).length) (model.pivotTables || []).forEach((pivotTable) => {
+				const n = pivotTable.tableNumber;
 				xmlStream.leafNode("Override", {
-					PartName: "/xl/pivotCache/pivotCacheDefinition1.xml",
+					PartName: `/xl/pivotCache/pivotCacheDefinition${n}.xml`,
 					ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"
 				});
 				xmlStream.leafNode("Override", {
-					PartName: "/xl/pivotCache/pivotCacheRecords1.xml",
+					PartName: `/xl/pivotCache/pivotCacheRecords${n}.xml`,
 					ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"
 				});
 				xmlStream.leafNode("Override", {
-					PartName: "/xl/pivotTables/pivotTable1.xml",
+					PartName: `/xl/pivotTables/pivotTable${n}.xml`,
 					ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"
 				});
-			}
+			});
 			xmlStream.leafNode("Override", {
 				PartName: "/xl/theme/theme1.xml",
 				ContentType: "application/vnd.openxmlformats-officedocument.theme+xml"
@@ -39539,6 +39600,7 @@ ${XMLNS_NAMESPACE}.`);
 						calcProperties: {}
 					};
 					if (this.map.definedNames.model) this.model.definedNames = this.map.definedNames.model;
+					if (this.map.pivotCaches.model && this.map.pivotCaches.model.length > 0) this.model.pivotCaches = this.map.pivotCaches.model;
 					return false;
 				default: return true;
 			}
@@ -39935,6 +39997,10 @@ ${XMLNS_NAMESPACE}.`);
 							model.type = Enums.ValueType.Error;
 							model.value = { error: model.value };
 							break;
+						case "d":
+							model.type = Enums.ValueType.Date;
+							model.value = new Date(model.value);
+							break;
 						default:
 							model.type = Enums.ValueType.Number;
 							model.value = parseFloat(model.value);
@@ -42521,10 +42587,12 @@ ${XMLNS_NAMESPACE}.`);
 					if (style) column.dxfId = options.styles.addDxfStyle(style);
 				});
 			});
-			if ((model.pivotTables || []).length) rels.push({
-				Id: nextRid(rels),
-				Type: RelType.PivotTable,
-				Target: "../pivotTables/pivotTable1.xml"
+			(model.pivotTables || []).forEach((pivotTable) => {
+				rels.push({
+					Id: nextRid(rels),
+					Type: RelType.PivotTable,
+					Target: `../pivotTables/pivotTable${pivotTable.tableNumber}.xml`
+				});
 			});
 			this.map.extLst.prepare(model, options);
 		}
@@ -42695,6 +42763,13 @@ ${XMLNS_NAMESPACE}.`);
 				const rel = rels[tablePart.rId];
 				return options.tables[rel.Target];
 			});
+			model.pivotTables = [];
+			(model.relationships || []).forEach((rel) => {
+				if (rel.Type === RelType.PivotTable && options.pivotTables) {
+					const pivotTable = options.pivotTables[rel.Target];
+					if (pivotTable) model.pivotTables.push(pivotTable);
+				}
+			});
 			delete model.relationships;
 			delete model.hyperlinks;
 			delete model.comments;
@@ -43782,50 +43857,164 @@ ${XMLNS_NAMESPACE}.`);
 		constructor() {
 			super();
 			this.map = {};
+			this.model = null;
+			this.currentRecord = null;
 		}
 		prepare(_model) {}
 		get tag() {
 			return "pivotCacheRecords";
 		}
+		reset() {
+			this.model = null;
+			this.currentRecord = null;
+		}
+		/**
+		* Render pivot cache records XML.
+		* Supports both newly created models (with PivotTableSource) and loaded models.
+		*/
 		render(xmlStream, model) {
-			const { sourceSheet, cacheFields } = model;
-			const sourceBodyRows = sourceSheet.getSheetValues().slice(2);
+			if (model.isLoaded || !("source" in model)) this.renderLoaded(xmlStream, model);
+			else this.renderNew(xmlStream, model);
+		}
+		/**
+		* Render newly created pivot cache records
+		*/
+		renderNew(xmlStream, model) {
+			const { source, cacheFields } = model;
+			const sourceBodyRows = source.getSheetValues().slice(2);
 			xmlStream.openXml(XmlStream.StdDocAttributes);
 			xmlStream.openNode(this.tag, {
 				...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
 				count: sourceBodyRows.length
 			});
-			xmlStream.writeXml(renderTable());
+			xmlStream.writeXml(this.renderTableNew(sourceBodyRows, cacheFields));
 			xmlStream.closeNode();
-			function renderTable() {
-				return sourceBodyRows.map((row) => {
-					return [...renderRowLines(row.slice(1))].join("");
-				}).join("");
-			}
-			function* renderRowLines(row) {
-				yield "\n  <r>";
-				for (const [index, cellValue] of row.entries()) {
-					yield "\n    ";
-					yield renderCell(cellValue, cacheFields[index].sharedItems);
+		}
+		/**
+		* Render loaded pivot cache records
+		*/
+		renderLoaded(xmlStream, model) {
+			xmlStream.openXml(XmlStream.StdDocAttributes);
+			xmlStream.openNode(this.tag, {
+				...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
+				count: model.count
+			});
+			for (const record of model.records) {
+				xmlStream.writeXml("\n  <r>");
+				for (const value of record) {
+					xmlStream.writeXml("\n    ");
+					xmlStream.writeXml(this.renderRecordValue(value));
 				}
-				yield "\n  </r>";
+				xmlStream.writeXml("\n  </r>");
+			}
+			xmlStream.closeNode();
+		}
+		/**
+		* Render a single record value to XML
+		*/
+		renderRecordValue(value) {
+			switch (value.type) {
+				case "x": return `<x v="${value.value}" />`;
+				case "n": return `<n v="${value.value}" />`;
+				case "s": return `<s v="${xmlEncode(String(value.value))}" />`;
+				case "b": return `<b v="${value.value ? "1" : "0"}" />`;
+				case "m": return "<m />";
+				case "d": return `<d v="${value.value.toISOString()}" />`;
+				case "e": return `<e v="${value.value}" />`;
+				default: return "<m />";
 			}
-			function renderCell(value, sharedItems) {
-				if (sharedItems === null) {
-					if (Number.isFinite(value)) return `<n v="${value}" />`;
-					return `<s v="${value}" />`;
+		}
+		renderTableNew(sourceBodyRows, cacheFields) {
+			const parts = [];
+			for (const row of sourceBodyRows) {
+				const realRow = row.slice(1);
+				parts.push("\n  <r>");
+				for (let i$1 = 0; i$1 < realRow.length; i$1++) {
+					parts.push("\n    ");
+					parts.push(this.renderCellNew(realRow[i$1], cacheFields[i$1].sharedItems));
 				}
-				const sharedItemsIndex = sharedItems.indexOf(value);
-				if (sharedItemsIndex < 0) throw new Error(`${JSON.stringify(value)} not in sharedItems ${JSON.stringify(sharedItems)}`);
-				return `<x v="${sharedItemsIndex}" />`;
+				parts.push("\n  </r>");
 			}
+			return parts.join("");
 		}
-		parseOpen(_node) {
-			return false;
+		renderCellNew(value, sharedItems) {
+			if (value === null || value === void 0) return "<m />";
+			if (sharedItems === null) {
+				if (Number.isFinite(value)) return `<n v="${value}" />`;
+				return `<s v="${xmlEncode(String(value))}" />`;
+			}
+			const sharedItemsIndex = sharedItems.indexOf(value);
+			if (sharedItemsIndex < 0) throw new Error(`${JSON.stringify(value)} not in sharedItems ${JSON.stringify(sharedItems)}`);
+			return `<x v="${sharedItemsIndex}" />`;
+		}
+		parseOpen(node) {
+			const { name, attributes } = node;
+			switch (name) {
+				case this.tag:
+					this.reset();
+					this.model = {
+						records: [],
+						count: parseInt(attributes.count || "0", 10),
+						isLoaded: true
+					};
+					break;
+				case "r":
+					this.currentRecord = [];
+					break;
+				case "x":
+					if (this.currentRecord) this.currentRecord.push({
+						type: "x",
+						value: parseInt(attributes.v || "0", 10)
+					});
+					break;
+				case "n":
+					if (this.currentRecord) this.currentRecord.push({
+						type: "n",
+						value: parseFloat(attributes.v || "0")
+					});
+					break;
+				case "s":
+					if (this.currentRecord) this.currentRecord.push({
+						type: "s",
+						value: xmlDecode(attributes.v || "")
+					});
+					break;
+				case "b":
+					if (this.currentRecord) this.currentRecord.push({
+						type: "b",
+						value: attributes.v === "1"
+					});
+					break;
+				case "m":
+					if (this.currentRecord) this.currentRecord.push({ type: "m" });
+					break;
+				case "d":
+					if (this.currentRecord) this.currentRecord.push({
+						type: "d",
+						value: new Date(attributes.v || "")
+					});
+					break;
+				case "e":
+					if (this.currentRecord) this.currentRecord.push({
+						type: "e",
+						value: attributes.v || ""
+					});
+					break;
+			}
+			return true;
 		}
 		parseText(_text) {}
-		parseClose(_name) {
-			return false;
+		parseClose(name) {
+			switch (name) {
+				case this.tag: return false;
+				case "r":
+					if (this.model && this.currentRecord) {
+						this.model.records.push(this.currentRecord);
+						this.currentRecord = null;
+					}
+					break;
+			}
+			return true;
 		}
 		reconcile(_model, _options) {}
 		static {
@@ -43847,30 +44036,157 @@ ${XMLNS_NAMESPACE}.`);
 			this.sharedItems = sharedItems;
 		}
 		render() {
-			if (this.sharedItems === null) return `<cacheField name="${this.name}" numFmtId="0">
+			const escapedName = xmlEncode(this.name);
+			if (this.sharedItems === null) return `<cacheField name="${escapedName}" numFmtId="0">
       <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" />
     </cacheField>`;
-			return `<cacheField name="${this.name}" numFmtId="0">
+			return `<cacheField name="${escapedName}" numFmtId="0">
       <sharedItems count="${this.sharedItems.length}">
-        ${this.sharedItems.map((item) => `<s v="${item}" />`).join("")}
+        ${this.sharedItems.map((item) => `<s v="${xmlEncode(String(item))}" />`).join("")}
       </sharedItems>
     </cacheField>`;
 		}
 	};
 
+//#endregion
+//#region src/xlsx/xform/pivot-table/cache-field-xform.ts
+/**
+	* Xform for parsing individual <cacheField> elements within a pivot cache definition.
+	*
+	* Example XML:
+	* ```xml
+	* <cacheField name="Category" numFmtId="0">
+	*   <sharedItems count="3">
+	*     <s v="A" />
+	*     <s v="B" />
+	*     <s v="C" />
+	*   </sharedItems>
+	* </cacheField>
+	*
+	* <cacheField name="Value" numFmtId="0">
+	*   <sharedItems containsSemiMixedTypes="0" containsString="0"
+	*                containsNumber="1" containsInteger="1" minValue="5" maxValue="45" />
+	* </cacheField>
+	* ```
+	*/
+	var CacheFieldXform = class extends BaseXform {
+		constructor() {
+			super();
+			this.model = null;
+			this.inSharedItems = false;
+		}
+		get tag() {
+			return "cacheField";
+		}
+		reset() {
+			this.model = null;
+			this.inSharedItems = false;
+		}
+		parseOpen(node) {
+			const { name, attributes } = node;
+			switch (name) {
+				case "cacheField":
+					this.model = {
+						name: xmlDecode(attributes.name || ""),
+						sharedItems: null
+					};
+					break;
+				case "sharedItems":
+					this.inSharedItems = true;
+					if (attributes.containsNumber === "1" || attributes.containsInteger === "1") {
+						if (this.model) {
+							this.model.containsNumber = attributes.containsNumber === "1";
+							this.model.containsInteger = attributes.containsInteger === "1";
+							if (attributes.minValue !== void 0) this.model.minValue = parseFloat(attributes.minValue);
+							if (attributes.maxValue !== void 0) this.model.maxValue = parseFloat(attributes.maxValue);
+							this.model.sharedItems = null;
+						}
+					} else if (this.model) {
+						if (parseInt(attributes.count || "0", 10) > 0) this.model.sharedItems = [];
+					}
+					break;
+				case "s":
+					if (this.inSharedItems && this.model?.sharedItems !== null) {
+						const value = xmlDecode(attributes.v || "");
+						this.model.sharedItems.push(value);
+					}
+					break;
+				case "n":
+					if (this.inSharedItems && this.model?.sharedItems !== null) {
+						const value = parseFloat(attributes.v || "0");
+						this.model.sharedItems.push(value);
+					}
+					break;
+				case "b":
+					if (this.inSharedItems && this.model?.sharedItems !== null) {
+						const value = attributes.v === "1";
+						this.model.sharedItems.push(value);
+					}
+					break;
+				case "e":
+					if (this.inSharedItems && this.model?.sharedItems !== null) {
+						const value = `#${attributes.v || "ERROR!"}`;
+						this.model.sharedItems.push(value);
+					}
+					break;
+				case "m":
+					if (this.inSharedItems && this.model?.sharedItems !== null) this.model.sharedItems.push(null);
+					break;
+				case "d":
+					if (this.inSharedItems && this.model?.sharedItems !== null) {
+						const value = new Date(attributes.v || "");
+						this.model.sharedItems.push(value);
+					}
+					break;
+			}
+			return true;
+		}
+		parseText(_text) {}
+		parseClose(name) {
+			switch (name) {
+				case "cacheField": return false;
+				case "sharedItems":
+					this.inSharedItems = false;
+					break;
+			}
+			return true;
+		}
+	};
+
 //#endregion
 //#region src/xlsx/xform/pivot-table/pivot-cache-definition-xform.ts
 	var PivotCacheDefinitionXform = class PivotCacheDefinitionXform extends BaseXform {
 		constructor() {
 			super();
 			this.map = {};
+			this.model = null;
+			this.currentCacheField = null;
+			this.inCacheFields = false;
+			this.inCacheSource = false;
 		}
 		prepare(_model) {}
 		get tag() {
 			return "pivotCacheDefinition";
 		}
+		reset() {
+			this.model = null;
+			this.currentCacheField = null;
+			this.inCacheFields = false;
+			this.inCacheSource = false;
+		}
+		/**
+		* Render pivot cache definition XML.
+		* Supports both newly created models (with PivotTableSource) and loaded models.
+		*/
 		render(xmlStream, model) {
-			const { sourceSheet, cacheFields } = model;
+			if (model.isLoaded || !("source" in model)) this.renderLoaded(xmlStream, model);
+			else this.renderNew(xmlStream, model);
+		}
+		/**
+		* Render newly created pivot cache definition
+		*/
+		renderNew(xmlStream, model) {
+			const { source, cacheFields } = model;
 			xmlStream.openXml(XmlStream.StdDocAttributes);
 			xmlStream.openNode(this.tag, {
 				...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
@@ -43885,8 +44201,8 @@ ${XMLNS_NAMESPACE}.`);
 			});
 			xmlStream.openNode("cacheSource", { type: "worksheet" });
 			xmlStream.leafNode("worksheetSource", {
-				ref: sourceSheet.dimensions.shortRange,
-				sheet: sourceSheet.name
+				ref: source.dimensions.shortRange,
+				sheet: source.name
 			});
 			xmlStream.closeNode();
 			xmlStream.openNode("cacheFields", { count: cacheFields.length });
@@ -43894,12 +44210,98 @@ ${XMLNS_NAMESPACE}.`);
 			xmlStream.closeNode();
 			xmlStream.closeNode();
 		}
-		parseOpen(_node) {
-			return false;
+		/**
+		* Render loaded pivot cache definition (preserving original structure)
+		*/
+		renderLoaded(xmlStream, model) {
+			const { cacheFields, sourceRef, sourceSheet, recordCount } = model;
+			xmlStream.openXml(XmlStream.StdDocAttributes);
+			xmlStream.openNode(this.tag, {
+				...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
+				"r:id": model.rId || "rId1",
+				refreshOnLoad: model.refreshOnLoad || "1",
+				refreshedBy: model.refreshedBy || "Author",
+				refreshedDate: model.refreshedDate || "45125.026046874998",
+				createdVersion: model.createdVersion || "8",
+				refreshedVersion: model.refreshedVersion || "8",
+				minRefreshableVersion: model.minRefreshableVersion || "3",
+				recordCount: recordCount || cacheFields.length + 1
+			});
+			xmlStream.openNode("cacheSource", { type: "worksheet" });
+			xmlStream.leafNode("worksheetSource", {
+				ref: sourceRef,
+				sheet: sourceSheet
+			});
+			xmlStream.closeNode();
+			xmlStream.openNode("cacheFields", { count: cacheFields.length });
+			xmlStream.writeXml(cacheFields.map((cacheField) => new CacheField(cacheField).render()).join("\n    "));
+			xmlStream.closeNode();
+			xmlStream.closeNode();
 		}
-		parseText(_text) {}
-		parseClose(_name) {
-			return false;
+		parseOpen(node) {
+			const { name, attributes } = node;
+			if (this.currentCacheField) {
+				this.currentCacheField.parseOpen(node);
+				return true;
+			}
+			switch (name) {
+				case this.tag:
+					this.reset();
+					this.model = {
+						cacheFields: [],
+						rId: attributes["r:id"],
+						refreshOnLoad: attributes.refreshOnLoad,
+						refreshedBy: attributes.refreshedBy,
+						refreshedDate: attributes.refreshedDate,
+						createdVersion: attributes.createdVersion,
+						refreshedVersion: attributes.refreshedVersion,
+						minRefreshableVersion: attributes.minRefreshableVersion,
+						recordCount: attributes.recordCount ? parseInt(attributes.recordCount, 10) : void 0,
+						isLoaded: true
+					};
+					break;
+				case "cacheSource":
+					this.inCacheSource = true;
+					break;
+				case "worksheetSource":
+					if (this.inCacheSource && this.model) {
+						this.model.sourceRef = attributes.ref;
+						this.model.sourceSheet = attributes.sheet;
+					}
+					break;
+				case "cacheFields":
+					this.inCacheFields = true;
+					break;
+				case "cacheField":
+					if (this.inCacheFields) {
+						this.currentCacheField = new CacheFieldXform();
+						this.currentCacheField.parseOpen(node);
+					}
+					break;
+			}
+			return true;
+		}
+		parseText(text) {
+			if (this.currentCacheField) this.currentCacheField.parseText(text);
+		}
+		parseClose(name) {
+			if (this.currentCacheField) {
+				if (!this.currentCacheField.parseClose(name)) {
+					if (this.model && this.currentCacheField.model) this.model.cacheFields.push(this.currentCacheField.model);
+					this.currentCacheField = null;
+				}
+				return true;
+			}
+			switch (name) {
+				case this.tag: return false;
+				case "cacheSource":
+					this.inCacheSource = false;
+					break;
+				case "cacheFields":
+					this.inCacheFields = false;
+					break;
+			}
+			return true;
 		}
 		reconcile(_model, _options) {}
 		static {
@@ -43919,17 +44321,53 @@ ${XMLNS_NAMESPACE}.`);
 		constructor() {
 			super();
 			this.map = {};
+			this.model = null;
+			this.inPivotFields = false;
+			this.inRowFields = false;
+			this.inColFields = false;
+			this.inDataFields = false;
+			this.inRowItems = false;
+			this.inColItems = false;
+			this.inLocation = false;
+			this.currentPivotField = null;
+			this.inItems = false;
+			this.inPivotTableStyleInfo = false;
 		}
 		prepare(_model) {}
 		get tag() {
 			return "pivotTableDefinition";
 		}
+		reset() {
+			this.model = null;
+			this.inPivotFields = false;
+			this.inRowFields = false;
+			this.inColFields = false;
+			this.inDataFields = false;
+			this.inRowItems = false;
+			this.inColItems = false;
+			this.inLocation = false;
+			this.currentPivotField = null;
+			this.inItems = false;
+			this.inPivotTableStyleInfo = false;
+		}
+		/**
+		* Render pivot table XML.
+		* Supports both newly created models and loaded models.
+		*/
 		render(xmlStream, model) {
-			const { rows, columns, values, cacheFields, cacheId } = model;
+			if (model.isLoaded) this.renderLoaded(xmlStream, model);
+			else this.renderNew(xmlStream, model);
+		}
+		/**
+		* Render newly created pivot table
+		*/
+		renderNew(xmlStream, model) {
+			const { rows, columns, values, cacheFields, cacheId, applyWidthHeightFormats } = model;
+			const uniqueUid = `{${v4_default().toUpperCase()}}`;
 			xmlStream.openXml(XmlStream.StdDocAttributes);
 			xmlStream.openNode(this.tag, {
 				...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
-				"xr:uid": "{267EE50F-B116-784D-8DC2-BA77DE3F4F4A}",
+				"xr:uid": uniqueUid,
 				name: "PivotTable2",
 				cacheId,
 				applyNumberFormats: "0",
@@ -43937,7 +44375,7 @@ ${XMLNS_NAMESPACE}.`);
 				applyFontFormats: "0",
 				applyPatternFormats: "0",
 				applyAlignmentFormats: "0",
-				applyWidthHeightFormats: "1",
+				applyWidthHeightFormats,
 				dataCaption: "Values",
 				updatedVersion: "8",
 				minRefreshableVersion: "3",
@@ -43960,19 +44398,14 @@ ${XMLNS_NAMESPACE}.`);
       <rowItems count="1">
         <i t="grand"><x /></i>
       </rowItems>
-      <colFields count="${columns.length}">
-        ${columns.map((columnIndex) => `<field x="${columnIndex}" />`).join("\n    ")}
+      <colFields count="${columns.length === 0 ? 1 : columns.length}">
+        ${columns.length === 0 ? "<field x=\"-2\" />" : columns.map((columnIndex) => `<field x="${columnIndex}" />`).join("\n    ")}
       </colFields>
       <colItems count="1">
         <i t="grand"><x /></i>
       </colItems>
       <dataFields count="${values.length}">
-        <dataField
-          name="Sum of ${cacheFields[values[0]].name}"
-          fld="${values[0]}"
-          baseField="0"
-          baseItem="0"
-        />
+        ${buildDataFields(cacheFields, values, model.metric)}
       </dataFields>
       <pivotTableStyleInfo
         name="PivotStyleLight16"
@@ -44005,12 +44438,260 @@ ${XMLNS_NAMESPACE}.`);
     `);
 			xmlStream.closeNode();
 		}
-		parseOpen(_node) {
-			return false;
+		/**
+		* Render loaded pivot table (preserving original structure)
+		*/
+		renderLoaded(xmlStream, model) {
+			const uniqueUid = model.uid || `{${v4_default().toUpperCase()}}`;
+			xmlStream.openXml(XmlStream.StdDocAttributes);
+			xmlStream.openNode(this.tag, {
+				...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
+				"xr:uid": uniqueUid,
+				name: model.name || "PivotTable1",
+				cacheId: model.cacheId,
+				applyNumberFormats: model.applyNumberFormats || "0",
+				applyBorderFormats: model.applyBorderFormats || "0",
+				applyFontFormats: model.applyFontFormats || "0",
+				applyPatternFormats: model.applyPatternFormats || "0",
+				applyAlignmentFormats: model.applyAlignmentFormats || "0",
+				applyWidthHeightFormats: model.applyWidthHeightFormats || "0",
+				dataCaption: model.dataCaption || "Values",
+				updatedVersion: model.updatedVersion || "8",
+				minRefreshableVersion: model.minRefreshableVersion || "3",
+				useAutoFormatting: model.useAutoFormatting ? "1" : "0",
+				itemPrintTitles: model.itemPrintTitles ? "1" : "0",
+				createdVersion: model.createdVersion || "8",
+				indent: model.indent !== void 0 ? String(model.indent) : "0",
+				compact: model.compact ? "1" : "0",
+				compactData: model.compactData ? "1" : "0",
+				multipleFieldFilters: model.multipleFieldFilters ? "1" : "0"
+			});
+			if (model.location) xmlStream.leafNode("location", {
+				ref: model.location.ref,
+				firstHeaderRow: model.location.firstHeaderRow,
+				firstDataRow: model.location.firstDataRow,
+				firstDataCol: model.location.firstDataCol
+			});
+			if (model.pivotFields.length > 0) {
+				xmlStream.openNode("pivotFields", { count: model.pivotFields.length });
+				for (const pivotField of model.pivotFields) this.renderPivotFieldLoaded(xmlStream, pivotField);
+				xmlStream.closeNode();
+			}
+			if (model.rowFields.length > 0) {
+				xmlStream.openNode("rowFields", { count: model.rowFields.length });
+				for (const fieldIndex of model.rowFields) xmlStream.leafNode("field", { x: fieldIndex });
+				xmlStream.closeNode();
+			}
+			xmlStream.writeXml(`
+      <rowItems count="1">
+        <i t="grand"><x /></i>
+      </rowItems>`);
+			const colFieldCount = model.colFields.length === 0 ? 1 : model.colFields.length;
+			xmlStream.openNode("colFields", { count: colFieldCount });
+			if (model.colFields.length === 0) xmlStream.leafNode("field", { x: -2 });
+			else for (const fieldIndex of model.colFields) xmlStream.leafNode("field", { x: fieldIndex });
+			xmlStream.closeNode();
+			xmlStream.writeXml(`
+      <colItems count="1">
+        <i t="grand"><x /></i>
+      </colItems>`);
+			if (model.dataFields.length > 0) {
+				xmlStream.openNode("dataFields", { count: model.dataFields.length });
+				for (const dataField of model.dataFields) {
+					const attrs = {
+						name: dataField.name,
+						fld: dataField.fld,
+						baseField: dataField.baseField ?? 0,
+						baseItem: dataField.baseItem ?? 0
+					};
+					if (dataField.subtotal && dataField.subtotal !== "sum") attrs.subtotal = dataField.subtotal;
+					xmlStream.leafNode("dataField", attrs);
+				}
+				xmlStream.closeNode();
+			}
+			xmlStream.leafNode("pivotTableStyleInfo", {
+				name: model.styleName || "PivotStyleLight16",
+				showRowHeaders: "1",
+				showColHeaders: "1",
+				showRowStripes: "0",
+				showColStripes: "0",
+				showLastColumn: "1"
+			});
+			xmlStream.writeXml(`
+      <extLst>
+        <ext
+          uri="{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}"
+          xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
+        >
+          <x14:pivotTableDefinition
+            hideValuesRow="1"
+            xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main"
+          />
+        </ext>
+        <ext
+          uri="{747A6164-185A-40DC-8AA5-F01512510D54}"
+          xmlns:xpdl="http://schemas.microsoft.com/office/spreadsheetml/2016/pivotdefaultlayout"
+        >
+          <xpdl:pivotTableDefinition16
+            EnabledSubtotalsDefault="0"
+            SubtotalsOnTopDefault="0"
+          />
+        </ext>
+      </extLst>
+    `);
+			xmlStream.closeNode();
+		}
+		/**
+		* Render a loaded pivot field
+		*/
+		renderPivotFieldLoaded(xmlStream, field) {
+			const attrs = {
+				compact: field.compact ? "1" : "0",
+				outline: field.outline ? "1" : "0",
+				showAll: field.showAll ? "1" : "0",
+				defaultSubtotal: field.defaultSubtotal ? "1" : "0"
+			};
+			if (field.axis) attrs.axis = field.axis;
+			if (field.dataField) attrs.dataField = "1";
+			if (field.items && field.items.length > 0) {
+				xmlStream.openNode("pivotField", attrs);
+				xmlStream.openNode("items", { count: field.items.length + 1 });
+				for (const itemIndex of field.items) xmlStream.leafNode("item", { x: itemIndex });
+				xmlStream.writeXml("<item t=\"default\" />");
+				xmlStream.closeNode();
+				xmlStream.closeNode();
+			} else xmlStream.leafNode("pivotField", attrs);
+		}
+		parseOpen(node) {
+			const { name, attributes } = node;
+			switch (name) {
+				case this.tag:
+					this.reset();
+					this.model = {
+						name: attributes.name,
+						cacheId: parseInt(attributes.cacheId || "0", 10),
+						uid: attributes["xr:uid"],
+						pivotFields: [],
+						rowFields: [],
+						colFields: [],
+						dataFields: [],
+						applyNumberFormats: attributes.applyNumberFormats,
+						applyBorderFormats: attributes.applyBorderFormats,
+						applyFontFormats: attributes.applyFontFormats,
+						applyPatternFormats: attributes.applyPatternFormats,
+						applyAlignmentFormats: attributes.applyAlignmentFormats,
+						applyWidthHeightFormats: attributes.applyWidthHeightFormats,
+						dataCaption: attributes.dataCaption,
+						updatedVersion: attributes.updatedVersion,
+						minRefreshableVersion: attributes.minRefreshableVersion,
+						createdVersion: attributes.createdVersion,
+						useAutoFormatting: attributes.useAutoFormatting === "1",
+						itemPrintTitles: attributes.itemPrintTitles === "1",
+						indent: attributes.indent ? parseInt(attributes.indent, 10) : 0,
+						compact: attributes.compact === "1",
+						compactData: attributes.compactData === "1",
+						multipleFieldFilters: attributes.multipleFieldFilters === "1",
+						isLoaded: true
+					};
+					break;
+				case "location":
+					if (this.model) this.model.location = {
+						ref: attributes.ref,
+						firstHeaderRow: attributes.firstHeaderRow ? parseInt(attributes.firstHeaderRow, 10) : void 0,
+						firstDataRow: attributes.firstDataRow ? parseInt(attributes.firstDataRow, 10) : void 0,
+						firstDataCol: attributes.firstDataCol ? parseInt(attributes.firstDataCol, 10) : void 0
+					};
+					break;
+				case "pivotFields":
+					this.inPivotFields = true;
+					break;
+				case "pivotField":
+					if (this.inPivotFields) this.currentPivotField = {
+						axis: attributes.axis,
+						dataField: attributes.dataField === "1",
+						items: [],
+						compact: attributes.compact === "1",
+						outline: attributes.outline === "1",
+						showAll: attributes.showAll === "1",
+						defaultSubtotal: attributes.defaultSubtotal === "1"
+					};
+					break;
+				case "items":
+					if (this.currentPivotField) this.inItems = true;
+					break;
+				case "item":
+					if (this.inItems && this.currentPivotField && attributes.x !== void 0) this.currentPivotField.items.push(parseInt(attributes.x, 10));
+					break;
+				case "rowFields":
+					this.inRowFields = true;
+					break;
+				case "colFields":
+					this.inColFields = true;
+					break;
+				case "dataFields":
+					this.inDataFields = true;
+					break;
+				case "rowItems":
+					this.inRowItems = true;
+					break;
+				case "colItems":
+					this.inColItems = true;
+					break;
+				case "field":
+					if (this.model) {
+						const fieldIndex = parseInt(attributes.x || "0", 10);
+						if (this.inRowFields) this.model.rowFields.push(fieldIndex);
+						else if (this.inColFields) this.model.colFields.push(fieldIndex);
+					}
+					break;
+				case "dataField":
+					if (this.inDataFields && this.model) this.model.dataFields.push({
+						name: xmlDecode(attributes.name || ""),
+						fld: parseInt(attributes.fld || "0", 10),
+						baseField: attributes.baseField ? parseInt(attributes.baseField, 10) : 0,
+						baseItem: attributes.baseItem ? parseInt(attributes.baseItem, 10) : 0,
+						subtotal: attributes.subtotal
+					});
+					break;
+				case "pivotTableStyleInfo":
+					if (this.model) this.model.styleName = attributes.name;
+					break;
+			}
+			return true;
 		}
 		parseText(_text) {}
-		parseClose(_name) {
-			return false;
+		parseClose(name) {
+			switch (name) {
+				case this.tag: return false;
+				case "pivotFields":
+					this.inPivotFields = false;
+					break;
+				case "pivotField":
+					if (this.currentPivotField && this.model) {
+						this.model.pivotFields.push(this.currentPivotField);
+						this.currentPivotField = null;
+					}
+					break;
+				case "items":
+					this.inItems = false;
+					break;
+				case "rowFields":
+					this.inRowFields = false;
+					break;
+				case "colFields":
+					this.inColFields = false;
+					break;
+				case "dataFields":
+					this.inDataFields = false;
+					break;
+				case "rowItems":
+					this.inRowItems = false;
+					break;
+				case "colItems":
+					this.inColItems = false;
+					break;
+			}
+			return true;
 		}
 		reconcile(_model, _options) {}
 		static {
@@ -44022,9 +44703,26 @@ ${XMLNS_NAMESPACE}.`);
 			};
 		}
 	};
+	/**
+	* Build dataField XML elements for all values in the pivot table.
+	* Supports multiple values when columns is empty.
+	*/
+	function buildDataFields(cacheFields, values, metric) {
+		const metricName = metric === "count" ? "Count" : "Sum";
+		const subtotalAttr = metric === "count" ? " subtotal=\"count\"" : "";
+		return values.map((valueIndex) => `<dataField
+          name="${metricName} of ${xmlEncode(cacheFields[valueIndex].name)}"
+          fld="${valueIndex}"
+          baseField="0"
+          baseItem="0"${subtotalAttr}
+        />`).join("");
+	}
 	function renderPivotFields(pivotTable) {
+		const rowSet = new Set(pivotTable.rows);
+		const colSet = new Set(pivotTable.columns);
+		const valueSet = new Set(pivotTable.values);
 		return pivotTable.cacheFields.map((cacheField, fieldIndex) => {
-			return renderPivotField(pivotTable.rows.indexOf(fieldIndex) >= 0 ? "row" : pivotTable.columns.indexOf(fieldIndex) >= 0 ? "column" : pivotTable.values.indexOf(fieldIndex) >= 0 ? "value" : null, cacheField.sharedItems);
+			return renderPivotField(rowSet.has(fieldIndex) ? "row" : colSet.has(fieldIndex) ? "column" : valueSet.has(fieldIndex) ? "value" : null, cacheField.sharedItems);
 		}).join("");
 	}
 	function renderPivotField(fieldType, sharedItems) {
@@ -44592,9 +45290,7 @@ ${XMLNS_NAMESPACE}.`);
 
 //#endregion
 //#region src/xlsx/xlsx.ts
-	var import_buffer$2 = require_buffer$1();
 	init_empty();
-	var import_stream_browserify = require_stream_browserify();
 	function fsReadFileAsync(filename, options) {
 		return new Promise((resolve, reject) => {
 			empty.readFile(filename, options, (error, data) => {
@@ -44660,6 +45356,7 @@ ${XMLNS_NAMESPACE}.`);
 			Object.values(model.tables).forEach((table) => {
 				tableXform.reconcile(table, tableOptions);
 			});
+			this._reconcilePivotTables(model);
 			const sheetOptions = {
 				styles: model.styles,
 				sharedStrings: model.sharedStrings,
@@ -44669,7 +45366,8 @@ ${XMLNS_NAMESPACE}.`);
 				drawings: model.drawings,
 				comments: model.comments,
 				tables: model.tables,
-				vmlDrawings: model.vmlDrawings
+				vmlDrawings: model.vmlDrawings,
+				pivotTables: model.pivotTablesIndexed
 			};
 			model.worksheets.forEach((worksheet) => {
 				worksheet.relationships = model.worksheetRels[worksheet.sheetNo];
@@ -44686,6 +45384,99 @@ ${XMLNS_NAMESPACE}.`);
 			delete model.drawings;
 			delete model.drawingRels;
 			delete model.vmlDrawings;
+			delete model.pivotTableRels;
+			delete model.pivotCacheDefinitionRels;
+		}
+		/**
+		* Reconcile pivot tables by linking them to worksheets and their cache data.
+		* This builds a complete pivot table model ready for writing.
+		*/
+		_reconcilePivotTables(model) {
+			const rawPivotTables = model.pivotTables || {};
+			if (typeof rawPivotTables !== "object" || Object.keys(rawPivotTables).length === 0) {
+				model.pivotTables = [];
+				model.pivotTablesIndexed = {};
+				return;
+			}
+			const definitionToCacheId = this._buildDefinitionToCacheIdMap(model);
+			const cacheMap = /* @__PURE__ */ new Map();
+			Object.entries(model.pivotCacheDefinitions || {}).forEach(([name, definition]) => {
+				const cacheId = definitionToCacheId.get(name);
+				if (cacheId !== void 0) {
+					const recordsName = name.replace("Definition", "Records");
+					cacheMap.set(cacheId, {
+						definition,
+						records: model.pivotCacheRecords?.[recordsName],
+						definitionName: name
+					});
+				}
+			});
+			const loadedPivotTables = [];
+			const pivotTablesIndexed = {};
+			Object.entries(rawPivotTables).forEach(([pivotName, pivotTable]) => {
+				const pt = pivotTable;
+				const tableNumber = this._extractTableNumber(pivotName);
+				const cacheData = cacheMap.get(pt.cacheId);
+				const completePivotTable = {
+					...pt,
+					tableNumber,
+					cacheDefinition: cacheData?.definition,
+					cacheRecords: cacheData?.records,
+					cacheFields: cacheData?.definition?.cacheFields || [],
+					rows: pt.rowFields.filter((f) => f >= 0),
+					columns: pt.colFields.filter((f) => f >= 0 && f !== -2),
+					values: pt.dataFields.map((df) => df.fld),
+					metric: this._determineMetric(pt.dataFields),
+					applyWidthHeightFormats: pt.applyWidthHeightFormats || "0"
+				};
+				loadedPivotTables.push(completePivotTable);
+				pivotTablesIndexed[`../pivotTables/${pivotName}.xml`] = completePivotTable;
+			});
+			loadedPivotTables.sort((a, b) => a.tableNumber - b.tableNumber);
+			model.pivotTables = loadedPivotTables;
+			model.pivotTablesIndexed = pivotTablesIndexed;
+			model.loadedPivotTables = loadedPivotTables;
+		}
+		/**
+		* Extract table number from pivot table name (e.g., "pivotTable1" -> 1)
+		*/
+		_extractTableNumber(name) {
+			const match = name.match(/pivotTable(\d+)/);
+			return match ? parseInt(match[1], 10) : 1;
+		}
+		/**
+		* Build a mapping from rId to cacheId using pivotCaches from workbook.xml
+		* and workbookRels to determine which definition file corresponds to which cacheId
+		*/
+		_buildCacheIdMap(model) {
+			const rIdToCacheId = /* @__PURE__ */ new Map();
+			const pivotCaches = model.pivotCaches || [];
+			for (const cache of pivotCaches) if (cache.cacheId && cache.rId) rIdToCacheId.set(cache.rId, parseInt(cache.cacheId, 10));
+			return rIdToCacheId;
+		}
+		/**
+		* Build a mapping from definition name to cacheId
+		*/
+		_buildDefinitionToCacheIdMap(model) {
+			const definitionToCacheId = /* @__PURE__ */ new Map();
+			const rIdToCacheId = this._buildCacheIdMap(model);
+			const workbookRels = model.workbookRels || [];
+			for (const rel of workbookRels) if (rel.Type === XLSX.RelType.PivotCacheDefinition && rel.Target) {
+				const match = rel.Target.match(/pivotCacheDefinition(\d+)\.xml/);
+				if (match) {
+					const defName = `pivotCacheDefinition${match[1]}`;
+					const cacheId = rIdToCacheId.get(rel.Id);
+					if (cacheId !== void 0) definitionToCacheId.set(defName, cacheId);
+				}
+			}
+			return definitionToCacheId;
+		}
+		/**
+		* Determine the aggregation metric from dataFields
+		*/
+		_determineMetric(dataFields) {
+			if (dataFields.length > 0 && dataFields[0].subtotal === "count") return "count";
+			return "sum";
 		}
 		async _processWorksheetEntry(stream, model, sheetNo, options, path) {
 			const worksheet = await new WorkSheetXform(options).parseStream(stream);
@@ -44777,6 +45568,26 @@ ${XMLNS_NAMESPACE}.`);
 				stream.pipe(streamBuf);
 			});
 		}
+		async _processPivotTableEntry(stream, model, name) {
+			const pivotTable = await new PivotTableXform().parseStream(stream);
+			if (pivotTable) model.pivotTables[name] = pivotTable;
+		}
+		async _processPivotTableRelsEntry(stream, model, name) {
+			const relationships = await new RelationshipsXform().parseStream(stream);
+			model.pivotTableRels[name] = relationships;
+		}
+		async _processPivotCacheDefinitionEntry(stream, model, name) {
+			const cacheDefinition = await new PivotCacheDefinitionXform().parseStream(stream);
+			if (cacheDefinition) model.pivotCacheDefinitions[name] = cacheDefinition;
+		}
+		async _processPivotCacheDefinitionRelsEntry(stream, model, name) {
+			const relationships = await new RelationshipsXform().parseStream(stream);
+			model.pivotCacheDefinitionRels[name] = relationships;
+		}
+		async _processPivotCacheRecordsEntry(stream, model, name) {
+			const cacheRecords = await new PivotCacheRecordsXform().parseStream(stream);
+			if (cacheRecords) model.pivotCacheRecords[name] = cacheRecords;
+		}
 		async read(stream, options) {
 			const allFiles = {};
 			await new Promise((resolve, reject) => {
@@ -44847,8 +45658,8 @@ ${XMLNS_NAMESPACE}.`);
 		}
 		async load(data, options) {
 			let buffer;
-			if (!data || typeof data === "object" && !import_buffer$2.Buffer.isBuffer(data) && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer)) throw new Error("Can't read the data of 'the loaded zip file'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?");
-			if (options && options.base64) buffer = import_buffer$2.Buffer.from(data.toString(), "base64");
+			if (!data || typeof data === "object" && !import_buffer$3.Buffer.isBuffer(data) && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer)) throw new Error("Can't read the data of 'the loaded zip file'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?");
+			if (options && options.base64) buffer = import_buffer$3.Buffer.from(data.toString(), "base64");
 			else buffer = data;
 			const stream = new import_stream_browserify.PassThrough();
 			stream.end(buffer);
@@ -44866,7 +45677,12 @@ ${XMLNS_NAMESPACE}.`);
 				drawingRels: {},
 				comments: {},
 				tables: {},
-				vmlDrawings: {}
+				vmlDrawings: {},
+				pivotTables: {},
+				pivotTableRels: {},
+				pivotCacheDefinitions: {},
+				pivotCacheDefinitionRels: {},
+				pivotCacheRecords: {}
 			};
 			const entries = Object.keys(zipData).map((name) => ({
 				name,
@@ -44879,13 +45695,13 @@ ${XMLNS_NAMESPACE}.`);
 				let stream;
 				if (entryName.match(/xl\/media\//) || entryName.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/)) {
 					stream = new import_stream_browserify.PassThrough();
-					stream.end(import_buffer$2.Buffer.from(entry.data));
+					stream.end(import_buffer$3.Buffer.from(entry.data));
 				} else {
 					stream = new import_stream_browserify.PassThrough({
 						readableObjectMode: true,
 						writableObjectMode: true
 					});
-					const content = bufferToString(import_buffer$2.Buffer.from(entry.data));
+					const content = bufferToString(import_buffer$3.Buffer.from(entry.data));
 					stream.end(content);
 				}
 				let match;
@@ -44904,6 +45720,7 @@ ${XMLNS_NAMESPACE}.`);
 						model.views = workbook.views;
 						model.properties = workbook.properties;
 						model.calcProperties = workbook.calcProperties;
+						model.pivotCaches = workbook.pivotCaches;
 						break;
 					}
 					case "xl/sharedStrings.xml":
@@ -44970,6 +45787,31 @@ ${XMLNS_NAMESPACE}.`);
 							await this._processThemeEntry(stream, model, match[1]);
 							break;
 						}
+						match = entryName.match(/xl\/pivotTables\/(pivotTable\d+)[.]xml/);
+						if (match) {
+							await this._processPivotTableEntry(stream, model, match[1]);
+							break;
+						}
+						match = entryName.match(/xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels/);
+						if (match) {
+							await this._processPivotTableRelsEntry(stream, model, match[1]);
+							break;
+						}
+						match = entryName.match(/xl\/pivotCache\/(pivotCacheDefinition\d+)[.]xml/);
+						if (match) {
+							await this._processPivotCacheDefinitionEntry(stream, model, match[1]);
+							break;
+						}
+						match = entryName.match(/xl\/pivotCache\/_rels\/(pivotCacheDefinition\d+)[.]xml[.]rels/);
+						if (match) {
+							await this._processPivotCacheDefinitionRelsEntry(stream, model, match[1]);
+							break;
+						}
+						match = entryName.match(/xl\/pivotCache\/(pivotCacheRecords\d+)[.]xml/);
+						if (match) {
+							await this._processPivotCacheRecordsEntry(stream, model, match[1]);
+							break;
+						}
 				}
 			}
 			this.reconcile(model, options);
@@ -45032,21 +45874,21 @@ ${XMLNS_NAMESPACE}.`);
 				Type: XLSX.RelType.SharedStrings,
 				Target: "sharedStrings.xml"
 			});
-			if ((model.pivotTables || []).length) {
-				const pivotTable = model.pivotTables[0];
+			(model.pivotTables || []).forEach((pivotTable) => {
 				pivotTable.rId = `rId${count++}`;
 				relationships.push({
 					Id: pivotTable.rId,
 					Type: XLSX.RelType.PivotCacheDefinition,
-					Target: "pivotCache/pivotCacheDefinition1.xml"
+					Target: `pivotCache/pivotCacheDefinition${pivotTable.tableNumber}.xml`
 				});
-			}
-			model.worksheets.forEach((worksheet) => {
+			});
+			model.worksheets.forEach((worksheet, index) => {
 				worksheet.rId = `rId${count++}`;
+				worksheet.fileIndex = index + 1;
 				relationships.push({
 					Id: worksheet.rId,
 					Type: XLSX.RelType.Worksheet,
-					Target: `worksheets/sheet${worksheet.id}.xml`
+					Target: `worksheets/sheet${worksheet.fileIndex}.xml`
 				});
 			});
 			const xml = new RelationshipsXform().toXml(relationships);
@@ -45068,22 +45910,23 @@ ${XMLNS_NAMESPACE}.`);
 			const relationshipsXform = new RelationshipsXform();
 			const commentsXform = new CommentsXform();
 			const vmlNotesXform = new VmlNotesXform();
-			model.worksheets.forEach((worksheet) => {
+			model.worksheets.forEach((worksheet, index) => {
+				const fileIndex = worksheet.fileIndex || index + 1;
 				let xmlStream = new XmlStream();
 				worksheetXform.render(xmlStream, worksheet);
-				zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${worksheet.id}.xml` });
+				zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${fileIndex}.xml` });
 				if (worksheet.rels && worksheet.rels.length) {
 					xmlStream = new XmlStream();
 					relationshipsXform.render(xmlStream, worksheet.rels);
-					zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${worksheet.id}.xml.rels` });
+					zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${fileIndex}.xml.rels` });
 				}
 				if (worksheet.comments.length > 0) {
 					xmlStream = new XmlStream();
 					commentsXform.render(xmlStream, worksheet);
-					zip.append(xmlStream.xml, { name: `xl/comments${worksheet.id}.xml` });
+					zip.append(xmlStream.xml, { name: `xl/comments${fileIndex}.xml` });
 					xmlStream = new XmlStream();
 					vmlNotesXform.render(xmlStream, worksheet);
-					zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${worksheet.id}.vml` });
+					zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${fileIndex}.vml` });
 				}
 			});
 		}
@@ -45135,29 +45978,42 @@ ${XMLNS_NAMESPACE}.`);
 		}
 		addPivotTables(zip, model) {
 			if (!model.pivotTables.length) return;
-			const pivotTable = model.pivotTables[0];
 			const pivotCacheRecordsXform = new PivotCacheRecordsXform();
 			const pivotCacheDefinitionXform = new PivotCacheDefinitionXform();
 			const pivotTableXform = new PivotTableXform();
 			const relsXform = new RelationshipsXform();
-			let xml = pivotCacheRecordsXform.toXml(pivotTable);
-			zip.append(xml, { name: "xl/pivotCache/pivotCacheRecords1.xml" });
-			xml = pivotCacheDefinitionXform.toXml(pivotTable);
-			zip.append(xml, { name: "xl/pivotCache/pivotCacheDefinition1.xml" });
-			xml = relsXform.toXml([{
-				Id: "rId1",
-				Type: XLSX.RelType.PivotCacheRecords,
-				Target: "pivotCacheRecords1.xml"
-			}]);
-			zip.append(xml, { name: "xl/pivotCache/_rels/pivotCacheDefinition1.xml.rels" });
-			xml = pivotTableXform.toXml(pivotTable);
-			zip.append(xml, { name: "xl/pivotTables/pivotTable1.xml" });
-			xml = relsXform.toXml([{
-				Id: "rId1",
-				Type: XLSX.RelType.PivotCacheDefinition,
-				Target: "../pivotCache/pivotCacheDefinition1.xml"
-			}]);
-			zip.append(xml, { name: "xl/pivotTables/_rels/pivotTable1.xml.rels" });
+			model.pivotTables.forEach((pivotTable) => {
+				const n = pivotTable.tableNumber;
+				if (pivotTable.isLoaded) {
+					if (pivotTable.cacheDefinition) {
+						const xml$1 = pivotCacheDefinitionXform.toXml(pivotTable.cacheDefinition);
+						zip.append(xml$1, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
+					}
+					if (pivotTable.cacheRecords) {
+						const xml$1 = pivotCacheRecordsXform.toXml(pivotTable.cacheRecords);
+						zip.append(xml$1, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+					}
+				} else {
+					let xml$1 = pivotCacheRecordsXform.toXml(pivotTable);
+					zip.append(xml$1, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
+					xml$1 = pivotCacheDefinitionXform.toXml(pivotTable);
+					zip.append(xml$1, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
+				}
+				let xml = relsXform.toXml([{
+					Id: "rId1",
+					Type: XLSX.RelType.PivotCacheRecords,
+					Target: `pivotCacheRecords${n}.xml`
+				}]);
+				zip.append(xml, { name: `xl/pivotCache/_rels/pivotCacheDefinition${n}.xml.rels` });
+				xml = pivotTableXform.toXml(pivotTable);
+				zip.append(xml, { name: `xl/pivotTables/pivotTable${n}.xml` });
+				xml = relsXform.toXml([{
+					Id: "rId1",
+					Type: XLSX.RelType.PivotCacheDefinition,
+					Target: `../pivotCache/pivotCacheDefinition${n}.xml`
+				}]);
+				zip.append(xml, { name: `xl/pivotTables/_rels/pivotTable${n}.xml.rels` });
+			});
 		}
 		_finalize(zip) {
 			return new Promise((resolve, reject) => {
@@ -50673,7 +51529,7 @@ ${XMLNS_NAMESPACE}.`);
 			this.views = value.views;
 			this._themes = value.themes;
 			this.media = value.media || [];
-			this.pivotTables = value.pivotTables || [];
+			this.pivotTables = value.pivotTables || value.loadedPivotTables || [];
 		}
 	};