@niicojs/excel 0.3.4 → 0.3.5

package/dist/index.cjs

@@ -91,6 +91,45 @@ var fflate = require('fflate');
     }
     return `${start}:${end}`;
 };
+/**
+ * Parses a qualified sheet + address reference.
+ * Supports Sheet!A1 and 'Sheet Name'!A1.
+ */ const parseSheetAddress = (reference)=>{
+    const exclamationIndex = reference.lastIndexOf('!');
+    if (exclamationIndex <= 0 || exclamationIndex >= reference.length - 1) {
+        throw new Error(`Invalid sheet address reference: ${reference}`);
+    }
+    const rawSheet = reference.slice(0, exclamationIndex);
+    const addressPart = reference.slice(exclamationIndex + 1);
+    const sheet = unquoteSheetName(rawSheet);
+    return {
+        sheet,
+        address: parseAddress(addressPart)
+    };
+};
+/**
+ * Parses a qualified sheet + range reference.
+ * Supports Sheet!A1:B10 and 'Sheet Name'!A1:B10.
+ */ const parseSheetRange = (reference)=>{
+    const exclamationIndex = reference.lastIndexOf('!');
+    if (exclamationIndex <= 0 || exclamationIndex >= reference.length - 1) {
+        throw new Error(`Invalid sheet range reference: ${reference}`);
+    }
+    const rawSheet = reference.slice(0, exclamationIndex);
+    const rangePart = reference.slice(exclamationIndex + 1);
+    const sheet = unquoteSheetName(rawSheet);
+    return {
+        sheet,
+        range: parseRange(rangePart)
+    };
+};
+const unquoteSheetName = (sheet)=>{
+    const trimmed = sheet.trim();
+    if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
+        return trimmed.slice(1, -1).replace(/''/g, "'");
+    }
+    return trimmed;
+};
 /**
  * Normalizes a range so start is always top-left and end is bottom-right
  */ const normalizeRange = (range)=>{
@@ -314,6 +353,10 @@ const formatDatePart = (value, token, locale)=>{
             return padNumber(value.getMonth() + 1, 2);
         case 'm':
             return String(value.getMonth() + 1);
+        case 'dddd':
+            return value.toLocaleString(locale, {
+                weekday: 'long'
+            });
         case 'dd':
             return padNumber(value.getDate(), 2);
         case 'd':
@@ -373,6 +416,7 @@ const tokenizeDateFormat = (format)=>{
             'mmm',
             'mm',
             'm',
+            'dddd',
             'dd',
             'd',
             'hh',
@@ -412,6 +456,9 @@ const isDateFormat = (format)=>{
     return /[ymdhss]/.test(lowered);
 };
 const formatDate = (value, format, locale)=>{
+    if (locale === 'fr-FR' && format === '[$-F800]dddd\\,\\ mmmm\\ dd\\,\\ yyyy') {
+        format = 'dddd, dd mmmm yyyy';
+    }
     const tokens = tokenizeDateFormat(format);
     return tokens.map((token)=>formatDatePart(value, token, locale)).join('');
 };
@@ -890,7 +937,7 @@ const builderOptions = {
     commentPropName: '#comment',
     cdataPropName: '#cdata',
     format: false,
-    suppressEmptyNode: false,
+    suppressEmptyNode: true,
     suppressBooleanAttributes: false
 };
 const parser = new fastXmlParser.XMLParser(parserOptions);
@@ -1276,15 +1323,14 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     }
 }
 
-/**
- * Represents a worksheet in a workbook
+/**
+ * Represents a worksheet in a workbook
  */ class Worksheet {
     constructor(workbook, name){
         this._cells = new Map();
         this._xmlNodes = null;
         this._dirty = false;
         this._mergedCells = new Set();
-        this._sheetData = [];
         this._columnWidths = new Map();
         this._rowHeights = new Map();
         this._frozenPane = null;
@@ -1292,36 +1338,57 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._boundsDirty = true;
         this._tables = [];
         this._preserveXml = false;
+        this._rawXml = null;
+        this._lazyParse = false;
         this._tableRelIds = null;
+        this._pivotTableRelIds = null;
         this._sheetViewsDirty = false;
         this._colsDirty = false;
         this._tablePartsDirty = false;
+        this._pivotTablePartsDirty = false;
         this._workbook = workbook;
         this._name = name;
     }
-    /**
-   * Get the workbook this sheet belongs to
+    /**
+   * Get the workbook this sheet belongs to
    */ get workbook() {
         return this._workbook;
     }
-    /**
-   * Get the sheet name
+    /**
+   * Get the sheet name
    */ get name() {
         return this._name;
     }
-    /**
-   * Set the sheet name
+    /**
+   * Set the sheet name
    */ set name(value) {
         this._name = value;
         this._dirty = true;
     }
-    /**
-   * Parse worksheet XML content
-   */ parse(xml) {
-        this._xmlNodes = parseXml(xml);
+    /**
+   * Parse worksheet XML content
+   */ parse(xml, options = {}) {
+        this._rawXml = xml;
+        this._xmlNodes = null;
+        this._preserveXml = true;
+        this._lazyParse = options.lazy ?? true;
+        if (!this._lazyParse) {
+            this._ensureParsed();
+        }
+    }
+    _ensureParsed() {
+        if (!this._lazyParse) return;
+        if (!this._rawXml) {
+            this._lazyParse = false;
+            return;
+        }
+        this._xmlNodes = parseXml(this._rawXml);
         this._preserveXml = true;
         const worksheet = findElement(this._xmlNodes, 'worksheet');
-        if (!worksheet) return;
+        if (!worksheet) {
+            this._lazyParse = false;
+            return;
+        }
         const worksheetChildren = getChildren(worksheet, 'worksheet');
         // Parse sheet views (freeze panes)
         const sheetViews = findElement(worksheetChildren, 'sheetViews');
@@ -1346,8 +1413,8 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         // Parse sheet data (cells)
         const sheetData = findElement(worksheetChildren, 'sheetData');
         if (sheetData) {
-            this._sheetData = getChildren(sheetData, 'sheetData');
-            this._parseSheetData(this._sheetData);
+            const rows = getChildren(sheetData, 'sheetData');
+            this._parseSheetData(rows);
         }
         // Parse column widths
         const cols = findElement(worksheetChildren, 'cols');
@@ -1379,9 +1446,10 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 }
             }
         }
+        this._lazyParse = false;
     }
-    /**
-   * Parse the sheetData element to extract cells
+    /**
+   * Parse the sheetData element to extract cells
    */ _parseSheetData(rows) {
         for (const rowNode of rows){
             if (!('row' in rowNode)) continue;
@@ -1403,8 +1471,8 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         }
         this._boundsDirty = true;
     }
-    /**
-   * Parse a cell XML node to CellData
+    /**
+   * Parse a cell XML node to CellData
    */ _parseCellNode(node) {
         const data = {};
         // Type attribute
@@ -1479,9 +1547,10 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         }
         return data;
     }
-    /**
-   * Get a cell by address or row/col
+    /**
+   * Get a cell by address or row/col
    */ cell(rowOrAddress, col) {
+        this._ensureParsed();
         const { row, col: c } = parseCellRef(rowOrAddress, col);
         const address = toAddress(row, c);
         let cell = this._cells.get(address);
@@ -1492,14 +1561,16 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         }
         return cell;
     }
-    /**
-   * Get an existing cell without creating it.
+    /**
+   * Get an existing cell without creating it.
    */ getCellIfExists(rowOrAddress, col) {
+        this._ensureParsed();
         const { row, col: c } = parseCellRef(rowOrAddress, col);
         const address = toAddress(row, c);
         return this._cells.get(address);
     }
     range(startRowOrRange, startCol, endRow, endCol) {
+        this._ensureParsed();
         let rangeAddr;
         if (typeof startRowOrRange === 'string') {
             rangeAddr = parseRange(startRowOrRange);
@@ -1520,9 +1591,10 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         }
         return new Range(this, rangeAddr);
     }
-    /**
-   * Merge cells in the given range
+    /**
+   * Merge cells in the given range
    */ mergeCells(rangeOrStart, end) {
+        this._ensureParsed();
         let rangeStr;
         if (end) {
             rangeStr = `${rangeOrStart}:${end}`;
@@ -1532,34 +1604,39 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._mergedCells.add(rangeStr);
         this._dirty = true;
     }
-    /**
-   * Unmerge cells in the given range
+    /**
+   * Unmerge cells in the given range
    */ unmergeCells(rangeStr) {
+        this._ensureParsed();
         this._mergedCells.delete(rangeStr);
         this._dirty = true;
     }
-    /**
-   * Get all merged cell ranges
+    /**
+   * Get all merged cell ranges
    */ get mergedCells() {
+        this._ensureParsed();
         return Array.from(this._mergedCells);
     }
-    /**
-   * Check if the worksheet has been modified
+    /**
+   * Check if the worksheet has been modified
    */ get dirty() {
+        this._ensureParsed();
         if (this._dirty) return true;
         for (const cell of this._cells.values()){
             if (cell.dirty) return true;
         }
         return false;
     }
-    /**
-   * Get all cells in the worksheet
+    /**
+   * Get all cells in the worksheet
    */ get cells() {
+        this._ensureParsed();
         return this._cells;
     }
-    /**
-   * Set a column width (0-based index or column letter)
+    /**
+   * Set a column width (0-based index or column letter)
    */ setColumnWidth(col, width) {
+        this._ensureParsed();
         if (!Number.isFinite(width) || width <= 0) {
             throw new Error('Column width must be a positive number');
         }
@@ -1571,15 +1648,17 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._colsDirty = true;
         this._dirty = true;
     }
-    /**
-   * Get a column width if set
+    /**
+   * Get a column width if set
    */ getColumnWidth(col) {
+        this._ensureParsed();
         const colIndex = typeof col === 'number' ? col : letterToCol(col);
         return this._columnWidths.get(colIndex);
     }
-    /**
-   * Set a row height (0-based index)
+    /**
+   * Set a row height (0-based index)
    */ setRowHeight(row, height) {
+        this._ensureParsed();
         if (!Number.isFinite(height) || height <= 0) {
             throw new Error('Row height must be a positive number');
         }
@@ -1590,14 +1669,16 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._colsDirty = true;
         this._dirty = true;
     }
-    /**
-   * Get a row height if set
+    /**
+   * Get a row height if set
    */ getRowHeight(row) {
+        this._ensureParsed();
         return this._rowHeights.get(row);
     }
-    /**
-   * Freeze panes at a given row/column split (counts from top-left)
+    /**
+   * Freeze panes at a given row/column split (counts from top-left)
    */ freezePane(rowSplit, colSplit) {
+        this._ensureParsed();
         if (rowSplit < 0 || colSplit < 0) {
             throw new Error('Freeze pane splits must be >= 0');
         }
@@ -1612,69 +1693,85 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._sheetViewsDirty = true;
         this._dirty = true;
     }
-    /**
-   * Get current frozen pane configuration
+    /**
+   * Get current frozen pane configuration
    */ getFrozenPane() {
+        this._ensureParsed();
         return this._frozenPane ? {
             ...this._frozenPane
         } : null;
     }
-    /**
-   * Get all tables in the worksheet
+    /**
+   * Get all tables in the worksheet
    */ get tables() {
+        this._ensureParsed();
         return [
             ...this._tables
         ];
     }
-    /**
-   * Get column width entries
-   * @internal
+    /**
+   * Get column width entries
+   * @internal
    */ getColumnWidths() {
+        this._ensureParsed();
         return new Map(this._columnWidths);
     }
-    /**
-   * Get row height entries
-   * @internal
+    /**
+   * Get row height entries
+   * @internal
    */ getRowHeights() {
+        this._ensureParsed();
         return new Map(this._rowHeights);
     }
-    /**
-   * Set table relationship IDs for tableParts generation.
-   * @internal
+    /**
+   * Set table relationship IDs for tableParts generation.
+   * @internal
    */ setTableRelIds(ids) {
+        this._ensureParsed();
         this._tableRelIds = ids ? [
             ...ids
         ] : null;
         this._tablePartsDirty = true;
     }
-    /**
-   * Create an Excel Table (ListObject) from a data range.
-   *
-   * Tables provide structured data features like auto-filter, banded styling,
-   * and total row with aggregation functions.
-   *
-   * @param config - Table configuration
-   * @returns Table instance for method chaining
-   *
-   * @example
-   * ```typescript
-   * // Create a table with default styling
-   * const table = sheet.createTable({
-   *   name: 'SalesData',
-   *   range: 'A1:D10',
-   * });
-   *
-   * // Create a table with total row
-   * const table = sheet.createTable({
-   *   name: 'SalesData',
-   *   range: 'A1:D10',
-   *   totalRow: true,
-   *   style: { name: 'TableStyleMedium2' }
-   * });
-   *
-   * table.setTotalFunction('Sales', 'sum');
-   * ```
+    /**
+   * Set pivot table relationship IDs for pivotTableParts generation.
+   * @internal
+   */ setPivotTableRelIds(ids) {
+        this._ensureParsed();
+        this._pivotTableRelIds = ids ? [
+            ...ids
+        ] : null;
+        this._pivotTablePartsDirty = true;
+    }
+    /**
+   * Create an Excel Table (ListObject) from a data range.
+   *
+   * Tables provide structured data features like auto-filter, banded styling,
+   * and total row with aggregation functions.
+   *
+   * @param config - Table configuration
+   * @returns Table instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * // Create a table with default styling
+   * const table = sheet.createTable({
+   *   name: 'SalesData',
+   *   range: 'A1:D10',
+   * });
+   *
+   * // Create a table with total row
+   * const table = sheet.createTable({
+   *   name: 'SalesData',
+   *   range: 'A1:D10',
+   *   totalRow: true,
+   *   style: { name: 'TableStyleMedium2' }
+   * });
+   *
+   * table.setTotalFunction('Sales', 'sum');
+   * ```
    */ createTable(config) {
+        this._ensureParsed();
         // Validate table name is unique within the workbook
         for (const sheet of this._workbook.sheetNames){
             const ws = this._workbook.sheet(sheet);
@@ -1696,24 +1793,25 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._dirty = true;
         return table;
     }
-    /**
+    /**
    * Convert sheet data to an array of JSON objects.
-   *
+   *
    * @param config - Configuration options
    * @returns Array of objects where keys are field names and values are cell values
    *
    * @example
-   * ```typescript
-   * // Using first row as headers
-   * const data = sheet.toJson();
-   *
-   * // Using custom field names
-   * const data = sheet.toJson({ fields: ['name', 'age', 'city'] });
-   *
-   * // Starting from a specific row/column
-   * const data = sheet.toJson({ startRow: 2, startCol: 1 });
-   * ```
+   * ```typescript
+   * // Using first row as headers
+   * const data = sheet.toJson();
+   *
+   * // Using custom field names
+   * const data = sheet.toJson({ fields: ['name', 'age', 'city'] });
+   *
+   * // Starting from a specific row/column
+   * const data = sheet.toJson({ startRow: 2, startCol: 1 });
+   * ```
    */ toJson(config = {}) {
+        this._ensureParsed();
         const { fields, startRow = 0, startCol = 0, endRow, endCol, stopOnEmptyRow = true, dateHandling = this._workbook.dateHandling, asText = false, locale } = config;
         // Get the bounds of data in the sheet
         const bounds = this._getDataBounds();
@@ -1785,8 +1883,8 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         }
         return value;
     }
-    /**
-   * Get the bounds of data in the sheet (min/max row and column with data)
+    /**
+   * Get the bounds of data in the sheet (min/max row and column with data)
    */ _getDataBounds() {
         if (!this._boundsDirty && this._dataBoundsCache) {
             return this._dataBoundsCache;
@@ -1822,9 +1920,13 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._boundsDirty = false;
         return this._dataBoundsCache;
     }
-    /**
-   * Generate XML for this worksheet
+    /**
+   * Generate XML for this worksheet
    */ toXml() {
+        if (this._lazyParse && !this._dirty && this._rawXml) {
+            return this._rawXml;
+        }
+        this._ensureParsed();
         const preserved = this._preserveXml && this._xmlNodes ? this._buildPreservedWorksheet() : null;
         // Build sheetData from cells
         const sheetDataNode = this._buildSheetDataNode();
@@ -1899,6 +2001,10 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         if (tablePartsNode) {
             worksheetChildren.push(tablePartsNode);
         }
+        const pivotTablePartsNode = this._buildPivotTablePartsNode();
+        if (pivotTablePartsNode) {
+            worksheetChildren.push(pivotTablePartsNode);
+        }
         const worksheetNode = createElement('worksheet', {
             xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
             'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships'
@@ -2023,6 +2129,15 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             count: String(this._tables.length)
         }, tablePartNodes);
     }
+    _buildPivotTablePartsNode() {
+        if (!this._pivotTableRelIds || this._pivotTableRelIds.length === 0) return null;
+        const pivotPartNodes = this._pivotTableRelIds.map((relId)=>createElement('pivotTablePart', {
+                'r:id': relId
+            }, []));
+        return createElement('pivotTableParts', {
+            count: String(pivotPartNodes.length)
+        }, pivotPartNodes);
+    }
     _buildPreservedWorksheet() {
         if (!this._xmlNodes) return null;
         const worksheet = findElement(this._xmlNodes, 'worksheet');
@@ -2056,10 +2171,14 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             const tablePartsNode = this._buildTablePartsNode();
             upsertChild('tableParts', tablePartsNode);
         }
+        if (this._pivotTablePartsDirty) {
+            const pivotTablePartsNode = this._buildPivotTablePartsNode();
+            upsertChild('pivotTableParts', pivotTablePartsNode);
+        }
         return worksheet;
     }
-    /**
-   * Build a cell XML node from a Cell object
+    /**
+   * Build a cell XML node from a Cell object
    */ _buildCellNode(cell) {
         const data = cell.data;
         const attrs = {
@@ -2099,32 +2218,45 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
    * Parse shared strings from XML content
    */ static parse(xml) {
         const ss = new SharedStrings();
-        const parsed = parseXml(xml);
+        ss._rawXml = xml;
+        ss._parse();
+        return ss;
+    }
+    _parse() {
+        if (this._parsed) return;
+        if (!this._rawXml) {
+            this._parsed = true;
+            return;
+        }
+        const parsed = parseXml(this._rawXml);
         const sst = findElement(parsed, 'sst');
-        if (!sst) return ss;
+        if (!sst) {
+            this._parsed = true;
+            return;
+        }
         const countAttr = getAttr(sst, 'count');
         if (countAttr) {
             const total = parseInt(countAttr, 10);
             if (Number.isFinite(total) && total >= 0) {
-                ss._totalCount = total;
+                this._totalCount = total;
             }
         }
         const children = getChildren(sst, 'sst');
         for (const child of children){
             if ('si' in child) {
                 const siChildren = getChildren(child, 'si');
-                const text = ss.extractText(siChildren);
-                ss.entries.push({
+                const text = this.extractText(siChildren);
+                this.entries.push({
                     text,
                     node: child
                 });
-                ss.stringToIndex.set(text, ss.entries.length - 1);
+                this.stringToIndex.set(text, this.entries.length - 1);
             }
         }
-        if (ss._totalCount === 0 && ss.entries.length > 0) {
-            ss._totalCount = ss.entries.length;
+        if (this._totalCount === 0 && this.entries.length > 0) {
+            this._totalCount = this.entries.length;
         }
-        return ss;
+        this._parsed = true;
     }
     /**
    * Extract text from a string item (si element)
@@ -2160,12 +2292,14 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     /**
    * Get a string by index
    */ getString(index) {
+        this._parse();
         return this.entries[index]?.text;
     }
     /**
    * Add a string and return its index
    * If the string already exists, returns the existing index
    */ addString(str) {
+        this._parse();
         const existing = this.stringToIndex.get(str);
         if (existing !== undefined) {
             this._totalCount++;
@@ -2193,26 +2327,31 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     /**
    * Check if the shared strings table has been modified
    */ get dirty() {
+        this._parse();
         return this._dirty;
     }
     /**
    * Get the count of strings
    */ get count() {
+        this._parse();
         return this.entries.length;
     }
     /**
    * Get total usage count of shared strings
    */ get totalCount() {
+        this._parse();
         return Math.max(this._totalCount, this.entries.length);
     }
     /**
    * Get all unique shared strings in insertion order.
    */ getAllStrings() {
+        this._parse();
         return this.entries.map((entry)=>entry.text);
     }
     /**
    * Generate XML for the shared strings table
    */ toXml() {
+        this._parse();
         const siElements = [];
         for (const entry of this.entries){
             if (entry.node) {
@@ -2245,6 +2384,8 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this.stringToIndex = new Map();
         this._dirty = false;
         this._totalCount = 0;
+        this._rawXml = null;
+        this._parsed = false;
     }
 }
 
@@ -2437,9 +2578,26 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
    * Parse styles from XML content
    */ static parse(xml) {
         const styles = new Styles();
-        styles._xmlNodes = parseXml(xml);
-        const styleSheet = findElement(styles._xmlNodes, 'styleSheet');
-        if (!styleSheet) return styles;
+        styles._rawXml = xml;
+        styles._parse();
+        return styles;
+    }
+    _parse() {
+        if (this._parsed) return;
+        if (!this._rawXml) {
+            this._parsed = true;
+            return;
+        }
+        this._xmlNodes = parseXml(this._rawXml);
+        if (!this._xmlNodes) {
+            this._parsed = true;
+            return;
+        }
+        const styleSheet = findElement(this._xmlNodes, 'styleSheet');
+        if (!styleSheet) {
+            this._parsed = true;
+            return;
+        }
         const children = getChildren(styleSheet, 'styleSheet');
         // Parse number formats
         const numFmts = findElement(children, 'numFmts');
@@ -2448,7 +2606,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 if ('numFmt' in child) {
                     const id = parseInt(getAttr(child, 'numFmtId') || '0', 10);
                     const code = getAttr(child, 'formatCode') || '';
-                    styles._numFmts.set(id, code);
+                    this._numFmts.set(id, code);
                 }
             }
         }
@@ -2457,7 +2615,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         if (fonts) {
             for (const child of getChildren(fonts, 'fonts')){
                 if ('font' in child) {
-                    styles._fonts.push(styles._parseFont(child));
+                    this._fonts.push(this._parseFont(child));
                 }
             }
         }
@@ -2466,7 +2624,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         if (fills) {
             for (const child of getChildren(fills, 'fills')){
                 if ('fill' in child) {
-                    styles._fills.push(styles._parseFill(child));
+                    this._fills.push(this._parseFill(child));
                 }
             }
         }
@@ -2475,7 +2633,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         if (borders) {
             for (const child of getChildren(borders, 'borders')){
                 if ('border' in child) {
-                    styles._borders.push(styles._parseBorder(child));
+                    this._borders.push(this._parseBorder(child));
                 }
             }
         }
@@ -2484,16 +2642,17 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         if (cellXfs) {
             for (const child of getChildren(cellXfs, 'cellXfs')){
                 if ('xf' in child) {
-                    styles._cellXfs.push(styles._parseCellXf(child));
+                    this._cellXfs.push(this._parseCellXf(child));
                 }
             }
         }
-        return styles;
+        this._parsed = true;
     }
     /**
    * Create an empty styles object with defaults
    */ static createDefault() {
         const styles = new Styles();
+        styles._parsed = true;
         // Default font (Calibri 11)
         styles._fonts.push({
             bold: false,
@@ -2633,6 +2792,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     /**
    * Get a style by index
    */ getStyle(index) {
+        this._parse();
         const cached = this._styleObjectCache.get(index);
         if (cached) return {
             ...cached
@@ -2699,6 +2859,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
    * Create a style and return its index
    * Uses caching to deduplicate identical styles
    */ createStyle(style) {
+        this._parse();
         const key = this._getStyleKey(style);
         const cached = this._styleCache.get(key);
         if (cached !== undefined) {
@@ -2739,6 +2900,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     /**
    * Clone an existing style by index, optionally overriding fields.
    */ cloneStyle(index, overrides = {}) {
+        this._parse();
         const baseStyle = this.getStyle(index);
         return this.createStyle({
             ...baseStyle,
@@ -2826,17 +2988,20 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
    * Returns built-in IDs (0-163) for standard formats, or creates custom IDs (164+).
    * @param format - The number format string (e.g., '0.00', '#,##0', '$#,##0.00')
    */ getOrCreateNumFmtId(format) {
+        this._parse();
         this._dirty = true;
         return this._findOrCreateNumFmt(format);
     }
     /**
    * Check if styles have been modified
    */ get dirty() {
+        this._parse();
         return this._dirty;
     }
     /**
    * Generate XML for styles
    */ toXml() {
+        this._parse();
         const children = [];
         // Number formats
         if (this._numFmts.size > 0) {
@@ -3028,6 +3193,8 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         this._borders = [];
         this._cellXfs = []; // Cell formats (combined style index)
         this._xmlNodes = null;
+        this._rawXml = null;
+        this._parsed = false;
         this._dirty = false;
         // Cache for style deduplication
         this._styleCache = new Map();
@@ -3035,313 +3202,361 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     }
 }
 
+const AGGREGATION_TO_XML = {
+    sum: 'sum',
+    count: 'count',
+    average: 'average',
+    min: 'min',
+    max: 'max'
+};
+const SORT_TO_XML = {
+    asc: 'ascending',
+    desc: 'descending'
+};
 /**
- * Represents an Excel pivot table with a fluent API for configuration.
+ * Represents an Excel PivotTable with a fluent configuration API.
  */ class PivotTable {
-    constructor(name, cache, targetSheet, targetCell, targetRow, targetCol, pivotTableIndex, cacheFileIndex){
+    constructor(workbook, config, sourceSheetName, sourceSheet, sourceRange, targetSheetName, targetCell, cacheId, pivotId, cachePartIndex, fields){
         this._rowFields = [];
         this._columnFields = [];
-        this._valueFields = [];
         this._filterFields = [];
-        this._fieldAssignments = new Map();
-        this._styles = null;
-        this._name = name;
-        this._cache = cache;
-        this._targetSheet = targetSheet;
+        this._valueFields = [];
+        this._sortOrders = new Map();
+        this._filters = new Map();
+        this._workbook = workbook;
+        this._name = config.name;
+        this._sourceSheetName = sourceSheetName;
+        this._sourceSheet = sourceSheet;
+        this._sourceRange = sourceRange;
+        this._targetSheetName = targetSheetName;
         this._targetCell = targetCell;
-        this._targetRow = targetRow;
-        this._targetCol = targetCol;
-        this._pivotTableIndex = pivotTableIndex;
-        this._cacheFileIndex = cacheFileIndex;
+        this._refreshOnLoad = config.refreshOnLoad !== false;
+        this._cacheId = cacheId;
+        this._pivotId = pivotId;
+        this._cachePartIndex = cachePartIndex;
+        this._fields = fields;
     }
-    /**
-   * Get the pivot table name
-   */ get name() {
+    get name() {
         return this._name;
     }
-    /**
-   * Get the target sheet name
-   */ get targetSheet() {
-        return this._targetSheet;
+    get sourceSheetName() {
+        return this._sourceSheetName;
     }
-    /**
-   * Get the target cell address
-   */ get targetCell() {
-        return this._targetCell;
+    get sourceRange() {
+        return {
+            start: {
+                ...this._sourceRange.start
+            },
+            end: {
+                ...this._sourceRange.end
+            }
+        };
     }
-    /**
-   * Get the pivot cache
-   */ get cache() {
-        return this._cache;
+    get targetSheetName() {
+        return this._targetSheetName;
     }
-    /**
-   * Get the pivot table index (for file naming)
-   */ get index() {
-        return this._pivotTableIndex;
+    get targetCell() {
+        return {
+            ...this._targetCell
+        };
     }
-    /**
-   * Get the pivot cache file index used for rels.
-   * @internal
-   */ get cacheFileIndex() {
-        return this._cacheFileIndex;
+    get refreshOnLoad() {
+        return this._refreshOnLoad;
     }
-    /**
-   * Set the styles reference for number format resolution
-   * @internal
-   */ setStyles(styles) {
-        this._styles = styles;
+    get cacheId() {
+        return this._cacheId;
+    }
+    get pivotId() {
+        return this._pivotId;
+    }
+    get cachePartIndex() {
+        return this._cachePartIndex;
+    }
+    addRowField(fieldName) {
+        this._assertFieldExists(fieldName);
+        if (!this._rowFields.includes(fieldName)) {
+            this._rowFields.push(fieldName);
+        }
         return this;
     }
-    /**
-   * Add a field to the row area
-   * @param fieldName - Name of the source field (column header)
-   */ addRowField(fieldName) {
-        const fieldIndex = this._cache.getFieldIndex(fieldName);
-        if (fieldIndex < 0) {
-            throw new Error(`Field not found in source data: ${fieldName}`);
+    addColumnField(fieldName) {
+        this._assertFieldExists(fieldName);
+        if (!this._columnFields.includes(fieldName)) {
+            this._columnFields.push(fieldName);
         }
-        const assignment = {
-            fieldName,
-            fieldIndex,
-            axis: 'row'
-        };
-        this._rowFields.push(assignment);
-        this._fieldAssignments.set(fieldIndex, assignment);
         return this;
     }
-    /**
-   * Add a field to the column area
-   * @param fieldName - Name of the source field (column header)
-   */ addColumnField(fieldName) {
-        const fieldIndex = this._cache.getFieldIndex(fieldName);
-        if (fieldIndex < 0) {
-            throw new Error(`Field not found in source data: ${fieldName}`);
+    addFilterField(fieldName) {
+        this._assertFieldExists(fieldName);
+        if (!this._filterFields.includes(fieldName)) {
+            this._filterFields.push(fieldName);
         }
-        const assignment = {
-            fieldName,
-            fieldIndex,
-            axis: 'column'
-        };
-        this._columnFields.push(assignment);
-        this._fieldAssignments.set(fieldIndex, assignment);
         return this;
     }
     addValueField(fieldNameOrConfig, aggregation = 'sum', displayName, numberFormat) {
-        // Normalize arguments to a common form
-        let fieldName;
-        let agg;
-        let name;
-        let format;
-        if (typeof fieldNameOrConfig === 'object') {
-            fieldName = fieldNameOrConfig.field;
-            agg = fieldNameOrConfig.aggregation ?? 'sum';
-            name = fieldNameOrConfig.name;
-            format = fieldNameOrConfig.numberFormat;
+        let config;
+        if (typeof fieldNameOrConfig === 'string') {
+            config = {
+                field: fieldNameOrConfig,
+                aggregation,
+                name: displayName,
+                numberFormat
+            };
         } else {
-            fieldName = fieldNameOrConfig;
-            agg = aggregation;
-            name = displayName;
-            format = numberFormat;
-        }
-        const fieldIndex = this._cache.getFieldIndex(fieldName);
-        if (fieldIndex < 0) {
-            throw new Error(`Field not found in source data: ${fieldName}`);
-        }
-        const defaultName = `${agg.charAt(0).toUpperCase() + agg.slice(1)} of ${fieldName}`;
-        // Resolve numFmtId immediately if format is provided and styles are available
-        let numFmtId;
-        if (format && this._styles) {
-            numFmtId = this._styles.getOrCreateNumFmtId(format);
-        }
-        const assignment = {
-            fieldName,
-            fieldIndex,
-            axis: 'value',
-            aggregation: agg,
-            displayName: name || defaultName,
-            numFmtId
-        };
-        this._valueFields.push(assignment);
-        this._fieldAssignments.set(fieldIndex, assignment);
+            config = fieldNameOrConfig;
+        }
+        this._assertFieldExists(config.field);
+        const resolvedAggregation = config.aggregation ?? 'sum';
+        const resolvedName = config.name ?? `${this._aggregationLabel(resolvedAggregation)} of ${config.field}`;
+        this._valueFields.push({
+            field: config.field,
+            aggregation: resolvedAggregation,
+            name: resolvedName,
+            numberFormat: config.numberFormat
+        });
         return this;
     }
-    /**
-   * Add a field to the filter (page) area
-   * @param fieldName - Name of the source field (column header)
-   */ addFilterField(fieldName) {
-        const fieldIndex = this._cache.getFieldIndex(fieldName);
-        if (fieldIndex < 0) {
-            throw new Error(`Field not found in source data: ${fieldName}`);
+    sortField(fieldName, order) {
+        this._assertFieldExists(fieldName);
+        if (!this._rowFields.includes(fieldName) && !this._columnFields.includes(fieldName)) {
+            throw new Error(`Cannot sort field "${fieldName}": only row or column fields can be sorted`);
         }
-        const assignment = {
-            fieldName,
-            fieldIndex,
-            axis: 'filter'
-        };
-        this._filterFields.push(assignment);
-        this._fieldAssignments.set(fieldIndex, assignment);
+        this._sortOrders.set(fieldName, order);
         return this;
     }
-    /**
-   * Set a sort order for a row or column field
-   * @param fieldName - Name of the field to sort
-   * @param order - Sort order ('asc' or 'desc')
-   */ sortField(fieldName, order) {
-        const fieldIndex = this._cache.getFieldIndex(fieldName);
-        if (fieldIndex < 0) {
-            throw new Error(`Field not found in source data: ${fieldName}`);
+    filterField(fieldName, filter) {
+        this._assertFieldExists(fieldName);
+        const hasInclude = 'include' in filter;
+        const hasExclude = 'exclude' in filter;
+        if (hasInclude && hasExclude || !hasInclude && !hasExclude) {
+            throw new Error('Pivot filter must contain either include or exclude');
         }
-        const assignment = this._fieldAssignments.get(fieldIndex);
-        if (!assignment) {
-            throw new Error(`Field is not assigned to pivot table: ${fieldName}`);
+        const values = hasInclude ? filter.include : filter.exclude;
+        if (!values || values.length === 0) {
+            throw new Error('Pivot filter values cannot be empty');
         }
-        if (assignment.axis !== 'row' && assignment.axis !== 'column') {
-            throw new Error(`Sort is only supported for row or column fields: ${fieldName}`);
-        }
-        assignment.sortOrder = order;
+        this._filters.set(fieldName, filter);
         return this;
     }
-    /**
-   * Filter items for a row, column, or filter field
-   * @param fieldName - Name of the field to filter
-   * @param filter - Filter configuration with include or exclude list
-   */ filterField(fieldName, filter) {
-        const fieldIndex = this._cache.getFieldIndex(fieldName);
-        if (fieldIndex < 0) {
-            throw new Error(`Field not found in source data: ${fieldName}`);
-        }
-        const assignment = this._fieldAssignments.get(fieldIndex);
-        if (!assignment) {
-            throw new Error(`Field is not assigned to pivot table: ${fieldName}`);
-        }
-        if (filter.include && filter.exclude) {
-            throw new Error('Cannot use both include and exclude in the same filter');
-        }
-        assignment.filter = filter;
-        return this;
+    toPivotCacheDefinitionXml() {
+        const cacheData = this._buildPivotCacheData();
+        return this._buildPivotCacheDefinitionXml(cacheData);
+    }
+    toPivotCacheRecordsXml() {
+        const cacheData = this._buildPivotCacheData();
+        return this._buildPivotCacheRecordsXml(cacheData);
+    }
+    toPivotCacheDefinitionRelsXml() {
+        const relsRoot = createElement('Relationships', {
+            xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
+        }, [
+            createElement('Relationship', {
+                Id: 'rId1',
+                Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords',
+                Target: `pivotCacheRecords${this._cachePartIndex}.xml`
+            }, [])
+        ]);
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
+            relsRoot
+        ])}`;
     }
     /**
-   * Generate the pivotTableDefinition XML
-   */ toXml() {
+   * @internal
+   */ buildPivotPartsXml() {
+        const cacheData = this._buildPivotCacheData();
+        return {
+            cacheDefinitionXml: this._buildPivotCacheDefinitionXml(cacheData),
+            cacheRecordsXml: this._buildPivotCacheRecordsXml(cacheData),
+            cacheRelsXml: this.toPivotCacheDefinitionRelsXml(),
+            pivotTableXml: this._buildPivotTableDefinitionXml(cacheData)
+        };
+    }
+    toPivotTableDefinitionXml() {
+        const cacheData = this._buildPivotCacheData();
+        return this._buildPivotTableDefinitionXml(cacheData);
+    }
+    _buildPivotCacheDefinitionXml(cacheData) {
+        const cacheFieldNodes = this._fields.map((field, index)=>this._buildCacheFieldNode(field, index, cacheData));
+        const attrs = {
+            xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+            'xmlns:mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006',
+            'mc:Ignorable': 'xr',
+            'xmlns:xr': 'http://schemas.microsoft.com/office/spreadsheetml/2014/revision',
+            'r:id': 'rId1',
+            createdVersion: '8',
+            minRefreshableVersion: '3',
+            refreshedVersion: '8',
+            refreshOnLoad: this._refreshOnLoad ? '1' : '0',
+            recordCount: String(cacheData.rowCount)
+        };
+        const cacheSourceNode = createElement('cacheSource', {
+            type: 'worksheet'
+        }, [
+            createElement('worksheetSource', {
+                sheet: this._sourceSheetName,
+                ref: toRange(this._sourceRange)
+            }, [])
+        ]);
+        const cacheFieldsNode = createElement('cacheFields', {
+            count: String(cacheFieldNodes.length)
+        }, cacheFieldNodes);
+        const extLstNode = createElement('extLst', {}, [
+            createElement('ext', {
+                uri: '{725AE2AE-9491-48be-B2B4-4EB974FC3084}',
+                'xmlns:x14': 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main'
+            }, [
+                createElement('x14:pivotCacheDefinition', {}, [])
+            ])
+        ]);
+        const root = createElement('pivotCacheDefinition', attrs, [
+            cacheSourceNode,
+            cacheFieldsNode,
+            extLstNode
+        ]);
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
+            root
+        ])}`;
+    }
+    _buildPivotCacheRecordsXml(cacheData) {
+        const recordNodes = cacheData.recordNodes;
+        const root = createElement('pivotCacheRecords', {
+            xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+            'xmlns:mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006',
+            'mc:Ignorable': 'xr',
+            'xmlns:xr': 'http://schemas.microsoft.com/office/spreadsheetml/2014/revision',
+            count: String(recordNodes.length)
+        }, recordNodes);
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
+            root
+        ])}`;
+    }
+    _buildPivotTableDefinitionXml(cacheData) {
+        const effectiveValueFields = this._valueFields.length > 0 ? [
+            this._valueFields[0]
+        ] : [];
+        const sourceFieldCount = this._fields.length;
+        const pivotFields = [];
+        const effectiveRowFieldName = this._rowFields[0];
+        const rowFieldIndexes = effectiveRowFieldName ? [
+            this._fieldIndex(effectiveRowFieldName)
+        ] : [];
+        const colFieldIndexes = this._columnFields.length > 0 ? [
+            this._fieldIndex(this._columnFields[0])
+        ] : [];
+        const valueFieldIndexes = new Set(effectiveValueFields.map((valueField)=>this._fieldIndex(valueField.field)));
+        for(let index = 0; index < this._fields.length; index++){
+            const field = this._fields[index];
+            const attrs = {
+                showAll: '0'
+            };
+            if (rowFieldIndexes.includes(index)) {
+                attrs.axis = 'axisRow';
+            } else if (colFieldIndexes.includes(index)) {
+                attrs.axis = 'axisCol';
+            }
+            if (valueFieldIndexes.has(index)) {
+                attrs.dataField = '1';
+            }
+            const sortOrder = this._sortOrders.get(field.name);
+            if (sortOrder) {
+                attrs.sortType = SORT_TO_XML[sortOrder];
+            }
+            const children = [];
+            if (rowFieldIndexes.includes(index) || colFieldIndexes.includes(index)) {
+                const distinctItems = cacheData.distinctItemsByField[index] ?? [];
+                const itemNodes = distinctItems.map((_item, itemIndex)=>createElement('item', {
+                        x: String(itemIndex)
+                    }, []));
+                itemNodes.push(createElement('item', {
+                    t: 'default'
+                }, []));
+                children.push(createElement('items', {
+                    count: String(itemNodes.length)
+                }, itemNodes));
+            }
+            pivotFields.push(createElement('pivotField', attrs, children));
+        }
         const children = [];
-        // Calculate location (estimate based on fields)
-        const locationRef = this._calculateLocationRef();
-        // Calculate first data row/col offsets (1-based, relative to pivot table)
-        // firstHeaderRow: row offset of column headers (usually 1)
-        // firstDataRow: row offset where data starts (after filters and column headers)
-        // firstDataCol: column offset where data starts (after row labels)
-        const filterRowCount = this._filterFields.length > 0 ? this._filterFields.length + 1 : 0;
-        const headerRows = this._columnFields.length > 0 ? 1 : 0;
-        const firstDataRow = filterRowCount + headerRows + 1;
-        const firstDataCol = this._rowFields.length > 0 ? this._rowFields.length : 1;
-        const locationNode = createElement('location', {
+        const locationRef = this._buildTargetAreaRef(cacheData);
+        children.push(createElement('location', {
             ref: locationRef,
-            firstHeaderRow: String(filterRowCount + 1),
-            firstDataRow: String(firstDataRow),
-            firstDataCol: String(firstDataCol)
-        }, []);
-        children.push(locationNode);
-        // Build pivotFields (one per source field)
-        const pivotFieldNodes = [];
-        for (const cacheField of this._cache.fields){
-            const fieldNode = this._buildPivotFieldNode(cacheField.index);
-            pivotFieldNodes.push(fieldNode);
-        }
+            firstHeaderRow: '1',
+            firstDataRow: '1',
+            firstDataCol: String(Math.max(1, this._rowFields.length + 1))
+        }, []));
         children.push(createElement('pivotFields', {
-            count: String(pivotFieldNodes.length)
-        }, pivotFieldNodes));
-        // Row fields
-        if (this._rowFields.length > 0) {
-            const rowFieldNodes = this._rowFields.map((f)=>createElement('field', {
-                    x: String(f.fieldIndex)
-                }, []));
+            count: String(sourceFieldCount)
+        }, pivotFields));
+        if (rowFieldIndexes.length > 0) {
             children.push(createElement('rowFields', {
-                count: String(rowFieldNodes.length)
-            }, rowFieldNodes));
-            // Row items
-            const rowItemNodes = this._buildRowItems();
+                count: String(rowFieldIndexes.length)
+            }, rowFieldIndexes.map((fieldIndex)=>createElement('field', {
+                    x: String(fieldIndex)
+                }, []))));
+            const distinctRowItems = cacheData.distinctItemsByField[rowFieldIndexes[0]] ?? [];
+            const rowItemNodes = [];
+            if (distinctRowItems.length > 0) {
+                rowItemNodes.push(createElement('i', {}, [
+                    createElement('x', {}, [])
+                ]));
+                for(let itemIndex = 1; itemIndex < distinctRowItems.length; itemIndex++){
+                    rowItemNodes.push(createElement('i', {}, [
+                        createElement('x', {
+                            v: String(itemIndex)
+                        }, [])
+                    ]));
+                }
+            }
+            rowItemNodes.push(createElement('i', {
+                t: 'grand'
+            }, [
+                createElement('x', {}, [])
+            ]));
             children.push(createElement('rowItems', {
                 count: String(rowItemNodes.length)
             }, rowItemNodes));
         }
-        // Column fields
-        if (this._columnFields.length > 0) {
-            const colFieldNodes = this._columnFields.map((f)=>createElement('field', {
-                    x: String(f.fieldIndex)
-                }, []));
-            // If we have multiple value fields, add -2 to indicate where "Values" header goes
-            if (this._valueFields.length > 1) {
-                colFieldNodes.push(createElement('field', {
-                    x: '-2'
-                }, []));
-            }
+        if (colFieldIndexes.length > 0) {
             children.push(createElement('colFields', {
-                count: String(colFieldNodes.length)
-            }, colFieldNodes));
-            // Column items - need to account for multiple value fields
-            const colItemNodes = this._buildColItems();
-            children.push(createElement('colItems', {
-                count: String(colItemNodes.length)
-            }, colItemNodes));
-        } else if (this._valueFields.length > 1) {
-            // If no column fields but we have multiple values, need colFields with -2 (data field indicator)
-            children.push(createElement('colFields', {
-                count: '1'
-            }, [
-                createElement('field', {
-                    x: '-2'
-                }, [])
-            ]));
-            // Column items for each value field
-            const colItemNodes = [];
-            for(let i = 0; i < this._valueFields.length; i++){
-                colItemNodes.push(createElement('i', {}, [
-                    createElement('x', i === 0 ? {} : {
-                        v: String(i)
-                    }, [])
-                ]));
-            }
-            children.push(createElement('colItems', {
-                count: String(colItemNodes.length)
-            }, colItemNodes));
-        } else if (this._valueFields.length === 1) {
-            // Single value field - just add a single column item
-            children.push(createElement('colItems', {
-                count: '1'
-            }, [
-                createElement('i', {}, [])
-            ]));
+                count: String(colFieldIndexes.length)
+            }, colFieldIndexes.map((fieldIndex)=>createElement('field', {
+                    x: String(fieldIndex)
+                }, []))));
         }
-        // Page (filter) fields
+        // Excel expects colItems even when no explicit column fields are configured.
+        children.push(createElement('colItems', {
+            count: '1'
+        }, [
+            createElement('i', {}, [])
+        ]));
         if (this._filterFields.length > 0) {
-            const pageFieldNodes = this._filterFields.map((f)=>createElement('pageField', {
-                    fld: String(f.fieldIndex),
-                    hier: '-1'
-                }, []));
             children.push(createElement('pageFields', {
-                count: String(pageFieldNodes.length)
-            }, pageFieldNodes));
-        }
-        // Data fields (values)
-        if (this._valueFields.length > 0) {
-            const dataFieldNodes = this._valueFields.map((f)=>{
+                count: String(this._filterFields.length)
+            }, this._filterFields.map((field, index)=>createElement('pageField', {
+                    fld: String(this._fieldIndex(field)),
+                    hier: '-1',
+                    item: String(index)
+                }, []))));
+        }
+        if (effectiveValueFields.length > 0) {
+            children.push(createElement('dataFields', {
+                count: String(effectiveValueFields.length)
+            }, effectiveValueFields.map((valueField)=>{
                 const attrs = {
-                    name: f.displayName || f.fieldName,
-                    fld: String(f.fieldIndex),
+                    name: valueField.name,
+                    fld: String(this._fieldIndex(valueField.field)),
                     baseField: '0',
                     baseItem: '0',
-                    subtotal: f.aggregation || 'sum'
+                    subtotal: AGGREGATION_TO_XML[valueField.aggregation]
                 };
-                if (f.numFmtId !== undefined) {
-                    attrs.numFmtId = String(f.numFmtId);
+                if (valueField.numberFormat) {
+                    attrs.numFmtId = String(this._workbook.styles.getOrCreateNumFmtId(valueField.numberFormat));
                 }
                 return createElement('dataField', attrs, []);
-            });
-            children.push(createElement('dataFields', {
-                count: String(dataFieldNodes.length)
-            }, dataFieldNodes));
+            })));
         }
-        // Pivot table style
         children.push(createElement('pivotTableStyleInfo', {
             name: 'PivotStyleMedium9',
             showRowHeaders: '1',
@@ -3350,672 +3565,400 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             showColStripes: '0',
             showLastColumn: '1'
         }, []));
-        const pivotTableNode = createElement('pivotTableDefinition', {
+        const attrs = {
             xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
             'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
             name: this._name,
-            cacheId: String(this._cache.cacheId),
+            cacheId: String(this._cacheId),
+            dataCaption: 'Values',
             applyNumberFormats: '1',
             applyBorderFormats: '0',
             applyFontFormats: '0',
             applyPatternFormats: '0',
             applyAlignmentFormats: '0',
             applyWidthHeightFormats: '1',
-            dataCaption: 'Values',
             updatedVersion: '8',
             minRefreshableVersion: '3',
+            createdVersion: '8',
             useAutoFormatting: '1',
             rowGrandTotals: '1',
             colGrandTotals: '1',
             itemPrintTitles: '1',
-            createdVersion: '8',
             indent: '0',
+            multipleFieldFilters: this._filters.size > 0 ? '1' : '0',
             outline: '1',
-            outlineData: '1',
-            multipleFieldFilters: '0'
-        }, children);
+            outlineData: '1'
+        };
+        const root = createElement('pivotTableDefinition', attrs, children);
         return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
-            pivotTableNode
+            root
         ])}`;
     }
-    /**
-   * Build a pivotField node for a given field index
-   */ _buildPivotFieldNode(fieldIndex) {
-        const attrs = {};
-        const children = [];
-        // Check if this field is assigned to an axis
-        const rowField = this._rowFields.find((f)=>f.fieldIndex === fieldIndex);
-        const colField = this._columnFields.find((f)=>f.fieldIndex === fieldIndex);
-        const filterField = this._filterFields.find((f)=>f.fieldIndex === fieldIndex);
-        const valueField = this._valueFields.find((f)=>f.fieldIndex === fieldIndex);
-        // Get the assignment to check for sort/filter options
-        const assignment = rowField || colField || filterField;
-        if (rowField) {
-            attrs.axis = 'axisRow';
-            attrs.showAll = '0';
-            // Add sort order if specified
-            if (rowField.sortOrder) {
-                attrs.sortType = rowField.sortOrder === 'asc' ? 'ascending' : 'descending';
-            }
-            // Add items for shared values
-            const cacheField = this._cache.fields[fieldIndex];
-            if (cacheField && cacheField.sharedItems.length > 0) {
-                const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
-                children.push(createElement('items', {
-                    count: String(itemNodes.length)
-                }, itemNodes));
-            }
-        } else if (colField) {
-            attrs.axis = 'axisCol';
-            attrs.showAll = '0';
-            // Add sort order if specified
-            if (colField.sortOrder) {
-                attrs.sortType = colField.sortOrder === 'asc' ? 'ascending' : 'descending';
-            }
-            const cacheField = this._cache.fields[fieldIndex];
-            if (cacheField && cacheField.sharedItems.length > 0) {
-                const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
-                children.push(createElement('items', {
-                    count: String(itemNodes.length)
-                }, itemNodes));
+    _buildCacheFieldNode(field, fieldIndex, cacheData) {
+        const info = cacheData.numericInfoByField[fieldIndex];
+        const isAxisField = cacheData.isAxisFieldByIndex[fieldIndex];
+        const isValueField = cacheData.isValueFieldByIndex[fieldIndex];
+        const allNonNullAreNumbers = info.nonNullCount > 0 && info.numericCount === info.nonNullCount;
+        if (isValueField || !isAxisField && allNonNullAreNumbers) {
+            const minValue = info.hasNumeric ? info.min : 0;
+            const maxValue = info.hasNumeric ? info.max : 0;
+            const hasInteger = info.hasNumeric ? info.allIntegers : true;
+            const attrs = {
+                containsSemiMixedTypes: '0',
+                containsString: '0',
+                containsNumber: '1',
+                minValue: String(minValue),
+                maxValue: String(maxValue)
+            };
+            if (hasInteger) {
+                attrs.containsInteger = '1';
             }
-        } else if (filterField) {
-            attrs.axis = 'axisPage';
-            attrs.showAll = '0';
-            const cacheField = this._cache.fields[fieldIndex];
-            if (cacheField && cacheField.sharedItems.length > 0) {
-                const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
-                children.push(createElement('items', {
-                    count: String(itemNodes.length)
-                }, itemNodes));
-            }
-        } else if (valueField) {
-            attrs.dataField = '1';
-            attrs.showAll = '0';
-        } else {
-            attrs.showAll = '0';
+            return createElement('cacheField', {
+                name: field.name,
+                numFmtId: '0'
+            }, [
+                createElement('sharedItems', attrs, [])
+            ]);
+        }
+        if (!isAxisField) {
+            return createElement('cacheField', {
+                name: field.name,
+                numFmtId: '0'
+            }, [
+                createElement('sharedItems', {}, [])
+            ]);
         }
-        return createElement('pivotField', attrs, children);
+        const sharedItems = cacheData.sharedItemsByField[fieldIndex] ?? [];
+        return createElement('cacheField', {
+            name: field.name,
+            numFmtId: '0'
+        }, [
+            createElement('sharedItems', {
+                count: String(sharedItems.length)
+            }, sharedItems)
+        ]);
     }
-    /**
-   * Build item nodes for a pivot field, with optional filtering
-   */ _buildItemNodes(sharedItems, filter) {
-        const itemNodes = [];
-        for(let i = 0; i < sharedItems.length; i++){
-            const itemValue = sharedItems[i];
-            const itemAttrs = {
-                x: String(i)
-            };
-            // Check if this item should be hidden
-            if (filter) {
-                let hidden = false;
-                if (filter.exclude && filter.exclude.includes(itemValue)) {
-                    hidden = true;
-                } else if (filter.include && !filter.include.includes(itemValue)) {
-                    hidden = true;
-                }
-                if (hidden) {
-                    itemAttrs.h = '1';
-                }
+    _buildTargetAreaRef(cacheData) {
+        const start = this._targetCell;
+        const estimatedRows = Math.max(3, this._estimateOutputRows(cacheData));
+        const estimatedCols = Math.max(1, this._rowFields.length + Math.max(1, this._valueFields.length));
+        const endRow = start.row + estimatedRows - 1;
+        const endCol = start.col + estimatedCols - 1;
+        return `${toAddress(start.row, start.col)}:${toAddress(endRow, endCol)}`;
+    }
+    _estimateOutputRows(cacheData) {
+        if (this._rowFields.length === 0) {
+            return 3;
+        }
+        const rowFieldIndex = this._fieldIndex(this._rowFields[0]);
+        const distinctItems = cacheData.distinctItemsByField[rowFieldIndex] ?? [];
+        return Math.max(3, distinctItems.length + 2);
+    }
+    _buildPivotCacheData() {
+        const rowCount = Math.max(0, this._sourceRange.end.row - this._sourceRange.start.row);
+        const fieldCount = this._fields.length;
+        const recordNodes = new Array(rowCount);
+        const sharedItemIndexByField = new Array(fieldCount).fill(null);
+        const sharedItemsByField = new Array(fieldCount).fill(null);
+        const distinctItemsByField = new Array(fieldCount).fill(null);
+        const numericInfoByField = new Array(fieldCount);
+        const isAxisFieldByIndex = new Array(fieldCount);
+        const isValueFieldByIndex = new Array(fieldCount);
+        const effectiveRowField = this._rowFields[0] ?? null;
+        const effectiveColumnField = this._columnFields[0] ?? null;
+        const filterFields = new Set(this._filterFields);
+        const valueFields = new Set(this._valueFields.map((valueField)=>valueField.field));
+        for(let fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++){
+            const fieldName = this._fields[fieldIndex].name;
+            const isAxisField = fieldName === effectiveRowField || fieldName === effectiveColumnField || filterFields.has(fieldName);
+            const isValueField = valueFields.has(fieldName);
+            isAxisFieldByIndex[fieldIndex] = isAxisField;
+            isValueFieldByIndex[fieldIndex] = isValueField;
+            if (isAxisField) {
+                sharedItemIndexByField[fieldIndex] = new Map();
+                sharedItemsByField[fieldIndex] = [];
+                distinctItemsByField[fieldIndex] = [];
             }
-            itemNodes.push(createElement('item', itemAttrs, []));
+            numericInfoByField[fieldIndex] = {
+                nonNullCount: 0,
+                numericCount: 0,
+                min: 0,
+                max: 0,
+                hasNumeric: false,
+                allIntegers: true
+            };
         }
-        // Add default subtotal item
-        itemNodes.push(createElement('item', {
-            t: 'default'
-        }, []));
-        return itemNodes;
-    }
-    /**
-   * Build row items based on unique values in row fields
-   */ _buildRowItems() {
-        const items = [];
-        if (this._rowFields.length === 0) return items;
-        // Get unique values from first row field
-        const firstRowField = this._rowFields[0];
-        const cacheField = this._cache.fields[firstRowField.fieldIndex];
-        if (cacheField && cacheField.sharedItems.length > 0) {
-            for(let i = 0; i < cacheField.sharedItems.length; i++){
-                items.push(createElement('i', {}, [
-                    createElement('x', i === 0 ? {} : {
-                        v: String(i)
-                    }, [])
-                ]));
+        for(let rowOffset = 0; rowOffset < rowCount; rowOffset++){
+            const row = this._sourceRange.start.row + 1 + rowOffset;
+            const valueNodes = [];
+            for(let fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++){
+                const field = this._fields[fieldIndex];
+                const cellValue = this._sourceSheet.getCellIfExists(row, field.sourceCol)?.value ?? null;
+                if (cellValue !== null) {
+                    const numericInfo = numericInfoByField[fieldIndex];
+                    numericInfo.nonNullCount++;
+                    if (typeof cellValue === 'number' && Number.isFinite(cellValue)) {
+                        numericInfo.numericCount++;
+                        if (!numericInfo.hasNumeric) {
+                            numericInfo.min = cellValue;
+                            numericInfo.max = cellValue;
+                            numericInfo.hasNumeric = true;
+                        } else {
+                            if (cellValue < numericInfo.min) numericInfo.min = cellValue;
+                            if (cellValue > numericInfo.max) numericInfo.max = cellValue;
+                        }
+                        if (!Number.isInteger(cellValue)) {
+                            numericInfo.allIntegers = false;
+                        }
+                    }
+                    if (isAxisFieldByIndex[fieldIndex]) {
+                        const distinctMap = sharedItemIndexByField[fieldIndex];
+                        const key = this._distinctKey(cellValue);
+                        let index = distinctMap.get(key);
+                        if (index === undefined) {
+                            index = distinctMap.size;
+                            distinctMap.set(key, index);
+                            distinctItemsByField[fieldIndex].push(cellValue);
+                            const sharedNode = this._buildSharedItemNode(cellValue);
+                            if (sharedNode) {
+                                sharedItemsByField[fieldIndex].push(sharedNode);
+                            }
+                        }
+                        valueNodes.push(createElement('x', {
+                            v: String(index)
+                        }, []));
+                        continue;
+                    }
+                }
+                valueNodes.push(this._buildRawCacheValueNode(cellValue));
             }
+            recordNodes[rowOffset] = createElement('r', {}, valueNodes);
         }
-        // Add grand total row
-        items.push(createElement('i', {
-            t: 'grand'
-        }, [
-            createElement('x', {}, [])
-        ]));
-        return items;
-    }
-    /**
-   * Build column items based on unique values in column fields
-   */ _buildColItems() {
-        const items = [];
-        if (this._columnFields.length === 0) return items;
-        // Get unique values from first column field
-        const firstColField = this._columnFields[0];
-        const cacheField = this._cache.fields[firstColField.fieldIndex];
-        if (cacheField && cacheField.sharedItems.length > 0) {
-            if (this._valueFields.length > 1) {
-                // Multiple value fields - need nested items for each column value + value field combination
-                for(let colIdx = 0; colIdx < cacheField.sharedItems.length; colIdx++){
-                    for(let valIdx = 0; valIdx < this._valueFields.length; valIdx++){
-                        const xNodes = [
-                            createElement('x', colIdx === 0 ? {} : {
-                                v: String(colIdx)
-                            }, []),
-                            createElement('x', valIdx === 0 ? {} : {
-                                v: String(valIdx)
-                            }, [])
-                        ];
-                        items.push(createElement('i', {}, xNodes));
-                    }
+        return {
+            rowCount,
+            recordNodes,
+            sharedItemIndexByField,
+            sharedItemsByField,
+            distinctItemsByField,
+            numericInfoByField,
+            isAxisFieldByIndex,
+            isValueFieldByIndex
+        };
+    }
+    _buildSharedItemNode(value) {
+        if (typeof value === 'string') {
+            return {
+                s: [],
+                ':@': {
+                    '@_v': value
                 }
-            } else {
-                // Single value field - simple column items
-                for(let i = 0; i < cacheField.sharedItems.length; i++){
-                    items.push(createElement('i', {}, [
-                        createElement('x', i === 0 ? {} : {
-                            v: String(i)
-                        }, [])
-                    ]));
+            };
+        }
+        if (typeof value === 'number') {
+            return createElement('n', {
+                v: String(value)
+            }, []);
+        }
+        if (typeof value === 'boolean') {
+            return createElement('b', {
+                v: value ? '1' : '0'
+            }, []);
+        }
+        if (value instanceof Date) {
+            return createElement('d', {
+                v: value.toISOString()
+            }, []);
+        }
+        return null;
+    }
+    _buildRawCacheValueNode(value) {
+        if (value === null) {
+            return createElement('m', {}, []);
+        }
+        if (typeof value === 'string') {
+            return {
+                s: [],
+                ':@': {
+                    '@_v': value
                 }
-            }
+            };
         }
-        // Add grand total column(s)
-        if (this._valueFields.length > 1) {
-            // Grand total for each value field
-            for(let valIdx = 0; valIdx < this._valueFields.length; valIdx++){
-                const xNodes = [
-                    createElement('x', {}, []),
-                    createElement('x', valIdx === 0 ? {} : {
-                        v: String(valIdx)
-                    }, [])
-                ];
-                items.push(createElement('i', {
-                    t: 'grand'
-                }, xNodes));
-            }
-        } else {
-            items.push(createElement('i', {
-                t: 'grand'
-            }, [
-                createElement('x', {}, [])
-            ]));
+        if (typeof value === 'number') {
+            return createElement('n', {
+                v: String(value)
+            }, []);
         }
-        return items;
-    }
-    /**
-   * Calculate the location reference for the pivot table output
-   */ _calculateLocationRef() {
-        // Estimate output size based on fields
-        const numRows = this._estimateRowCount();
-        const numCols = this._estimateColCount();
-        const startRow = this._targetRow;
-        const startCol = this._targetCol;
-        const endRow = startRow + numRows - 1;
-        const endCol = startCol + numCols - 1;
-        return `${this._colToLetter(startCol)}${startRow}:${this._colToLetter(endCol)}${endRow}`;
-    }
-    /**
-   * Estimate number of rows in pivot table output
-   */ _estimateRowCount() {
-        let count = 1; // Header row
-        // Add filter area rows
-        count += this._filterFields.length;
-        // Add row labels (unique values in row fields)
-        if (this._rowFields.length > 0) {
-            const firstRowField = this._rowFields[0];
-            const cacheField = this._cache.fields[firstRowField.fieldIndex];
-            count += (cacheField?.sharedItems.length || 1) + 1; // +1 for grand total
-        } else {
-            count += 1; // At least one data row
+        if (typeof value === 'boolean') {
+            return createElement('b', {
+                v: value ? '1' : '0'
+            }, []);
+        }
+        if (value instanceof Date) {
+            return createElement('d', {
+                v: value.toISOString()
+            }, []);
         }
-        return Math.max(count, 3);
+        return createElement('m', {}, []);
     }
-    /**
-   * Estimate number of columns in pivot table output
-   */ _estimateColCount() {
-        let count = 0;
-        // Row label columns
-        count += Math.max(this._rowFields.length, 1);
-        // Column labels (unique values in column fields)
-        if (this._columnFields.length > 0) {
-            const firstColField = this._columnFields[0];
-            const cacheField = this._cache.fields[firstColField.fieldIndex];
-            count += (cacheField?.sharedItems.length || 1) + 1; // +1 for grand total
-        } else {
-            // Value columns
-            count += Math.max(this._valueFields.length, 1);
+    _assertFieldExists(fieldName) {
+        if (!this._fields.some((field)=>field.name === fieldName)) {
+            throw new Error(`Pivot field not found: ${fieldName}`);
         }
-        return Math.max(count, 2);
     }
-    /**
-   * Convert 0-based column index to letter (A, B, ..., Z, AA, etc.)
-   */ _colToLetter(col) {
-        let result = '';
-        let n = col;
-        while(n >= 0){
-            result = String.fromCharCode(n % 26 + 65) + result;
-            n = Math.floor(n / 26) - 1;
+    _fieldIndex(fieldName) {
+        const index = this._fields.findIndex((field)=>field.name === fieldName);
+        if (index < 0) {
+            throw new Error(`Pivot field not found: ${fieldName}`);
         }
-        return result;
+        return index;
+    }
+    _aggregationLabel(aggregation) {
+        switch(aggregation){
+            case 'sum':
+                return 'Sum';
+            case 'count':
+                return 'Count';
+            case 'average':
+                return 'Average';
+            case 'min':
+                return 'Min';
+            case 'max':
+                return 'Max';
+        }
+    }
+    _distinctKey(value) {
+        if (value instanceof Date) {
+            return `d:${value.toISOString()}`;
+        }
+        if (typeof value === 'string') {
+            return `s:${value}`;
+        }
+        if (typeof value === 'number') {
+            return `n:${value}`;
+        }
+        if (typeof value === 'boolean') {
+            return `b:${value ? 1 : 0}`;
+        }
+        if (typeof value === 'object' && value && 'error' in value) {
+            return `e:${value.error}`;
+        }
+        return 'u:';
     }
 }
 
-/**
- * Manages the pivot cache (definition and records) for a pivot table.
- * The cache stores source data metadata and cached values.
- */ class PivotCache {
-    constructor(cacheId, sourceSheet, sourceRange, fileIndex){
-        this._fields = [];
-        this._records = [];
-        this._recordCount = 0;
-        this._saveData = true;
-        this._refreshOnLoad = true; // Default to true
-        // Optimized lookup: Map<fieldIndex, Map<stringValue, sharedItemsIndex>>
-        this._sharedItemsIndexMap = new Map();
-        this._blankItemIndexMap = new Map();
-        this._styles = null;
-        this._cacheId = cacheId;
-        this._fileIndex = fileIndex;
-        this._sourceSheet = sourceSheet;
-        this._sourceRange = sourceRange;
+class EagerZipStore {
+    constructor(files){
+        this._files = files;
     }
-    /**
-   * Set styles reference for number format resolution.
-   * @internal
-   */ setStyles(styles) {
-        this._styles = styles;
+    get(path) {
+        return this._files.get(path);
     }
-    /**
-   * Get the cache ID
-   */ get cacheId() {
-        return this._cacheId;
+    set(path, content) {
+        this._files.set(path, content);
     }
-    /**
-   * Get the file index for this cache (used for file naming).
-   */ get fileIndex() {
-        return this._fileIndex;
+    has(path) {
+        return this._files.has(path);
     }
-    /**
-   * Set refreshOnLoad option
-   */ set refreshOnLoad(value) {
-        this._refreshOnLoad = value;
+    delete(path) {
+        this._files.delete(path);
     }
-    /**
-   * Set saveData option
-   */ set saveData(value) {
-        this._saveData = value;
+    getText(path) {
+        const data = this._files.get(path);
+        if (!data) return undefined;
+        return fflate.strFromU8(data);
     }
-    /**
-   * Get refreshOnLoad option
-   */ get refreshOnLoad() {
-        return this._refreshOnLoad;
+    setText(path, content) {
+        this._files.set(path, fflate.strToU8(content));
     }
-    /**
-   * Get saveData option
-   */ get saveData() {
-        return this._saveData;
-    }
-    /**
-   * Get the source sheet name
-   */ get sourceSheet() {
-        return this._sourceSheet;
-    }
-    /**
-   * Get the source range
-   */ get sourceRange() {
-        return this._sourceRange;
-    }
-    /**
-   * Get the full source reference (Sheet!Range)
-   */ get sourceRef() {
-        return `${this._sourceSheet}!${this._sourceRange}`;
-    }
-    /**
-   * Get the fields in this cache
-   */ get fields() {
-        return this._fields;
+    toFiles() {
+        return Promise.resolve(this._files);
     }
-    /**
-   * Get the number of data records
-   */ get recordCount() {
-        return this._recordCount;
-    }
-    /**
-   * Build the cache from source data.
-   * @param headers - Array of column header names
-   * @param data - 2D array of data rows (excluding headers)
-   */ buildFromData(headers, data) {
-        this._recordCount = data.length;
-        // Initialize fields from headers
-        this._fields = headers.map((name, index)=>({
-                name,
-                index,
-                isNumeric: true,
-                isDate: false,
-                hasBoolean: false,
-                hasBlank: false,
-                numFmtId: undefined,
-                sharedItems: [],
-                minValue: undefined,
-                maxValue: undefined,
-                minDate: undefined,
-                maxDate: undefined
-            }));
-        // Use Maps for unique value collection during analysis
-        const sharedItemsMaps = this._fields.map(()=>new Map());
-        // Analyze data to determine field types and collect unique values
-        for (const row of data){
-            for(let colIdx = 0; colIdx < row.length && colIdx < this._fields.length; colIdx++){
-                const value = row[colIdx];
-                const field = this._fields[colIdx];
-                if (value === null || value === undefined) {
-                    field.hasBlank = true;
-                    continue;
-                }
-                if (typeof value === 'string') {
-                    field.isNumeric = false;
-                    const map = sharedItemsMaps[colIdx];
-                    if (!map.has(value)) {
-                        map.set(value, value);
-                    }
-                } else if (typeof value === 'number') {
-                    if (field.isDate) {
-                        const d = this._excelSerialToDate(value);
-                        if (!field.minDate || d < field.minDate) {
-                            field.minDate = d;
-                        }
-                        if (!field.maxDate || d > field.maxDate) {
-                            field.maxDate = d;
-                        }
-                    } else {
-                        if (field.minValue === undefined || value < field.minValue) {
-                            field.minValue = value;
-                        }
-                        if (field.maxValue === undefined || value > field.maxValue) {
-                            field.maxValue = value;
-                        }
-                    }
-                } else if (value instanceof Date) {
-                    field.isDate = true;
-                    field.isNumeric = false;
-                    if (!field.minDate || value < field.minDate) {
-                        field.minDate = value;
-                    }
-                    if (!field.maxDate || value > field.maxDate) {
-                        field.maxDate = value;
-                    }
-                } else if (typeof value === 'boolean') {
-                    field.isNumeric = false;
-                    field.hasBoolean = true;
-                }
-            }
-        }
-        // Resolve number formats if styles are available
-        if (this._styles) {
-            const dateFmtId = this._styles.getOrCreateNumFmtId('mm-dd-yy');
-            for (const field of this._fields){
-                if (field.isDate) {
-                    field.numFmtId = dateFmtId;
-                }
-            }
-        }
-        // Convert Sets to arrays and build reverse index Maps for O(1) lookup during XML generation
-        this._sharedItemsIndexMap.clear();
-        this._blankItemIndexMap.clear();
-        for(let colIdx = 0; colIdx < this._fields.length; colIdx++){
-            const field = this._fields[colIdx];
-            const map = sharedItemsMaps[colIdx];
-            // Convert Map values to array (maintains insertion order in ES6+)
-            field.sharedItems = Array.from(map.values());
-            // Build reverse lookup Map: value -> index
-            if (field.sharedItems.length > 0) {
-                const indexMap = new Map();
-                for(let i = 0; i < field.sharedItems.length; i++){
-                    indexMap.set(field.sharedItems[i], i);
-                }
-                this._sharedItemsIndexMap.set(colIdx, indexMap);
-                if (field.hasBlank) {
-                    const blankIndex = field.sharedItems.length;
-                    this._blankItemIndexMap.set(colIdx, blankIndex);
-                }
-            }
+}
+class LazyZipStore {
+    constructor(data){
+        this._files = new Map();
+        this._deleted = new Set();
+        this._entryNames = null;
+        this._data = data;
+    }
+    get(path) {
+        if (this._deleted.has(path)) return undefined;
+        const cached = this._files.get(path);
+        if (cached) return cached;
+        this._ensureIndex();
+        if (this._entryNames && !this._entryNames.has(path)) return undefined;
+        const result = fflate.unzipSync(this._data, {
+            filter: (file)=>file.name === path
+        });
+        const data = result[path];
+        if (data) {
+            this._files.set(path, data);
         }
-        // Store records
-        this._records = data;
+        return data;
     }
-    /**
-   * Get field by name
-   */ getField(name) {
-        return this._fields.find((f)=>f.name === name);
+    set(path, content) {
+        this._files.set(path, content);
+        this._deleted.delete(path);
+        if (this._entryNames) {
+            this._entryNames.add(path);
+        }
     }
-    /**
-   * Get field index by name
-   */ getFieldIndex(name) {
-        const field = this._fields.find((f)=>f.name === name);
-        return field ? field.index : -1;
+    has(path) {
+        if (this._deleted.has(path)) return false;
+        if (this._files.has(path)) return true;
+        this._ensureIndex();
+        return this._entryNames?.has(path) ?? false;
     }
-    /**
-   * Generate the pivotCacheDefinition XML
-   */ toDefinitionXml(recordsRelId) {
-        const cacheFieldNodes = this._fields.map((field)=>{
-            const sharedItemsAttrs = {};
-            const sharedItemChildren = [];
-            if (field.sharedItems.length > 0) {
-                // String field with shared items
-                const total = field.hasBlank ? field.sharedItems.length + 1 : field.sharedItems.length;
-                sharedItemsAttrs.count = String(total);
-                sharedItemsAttrs.containsString = '1';
-                if (field.hasBlank) {
-                    sharedItemsAttrs.containsBlank = '1';
-                }
-                for (const item of field.sharedItems){
-                    sharedItemChildren.push(createElement('s', {
-                        v: item
-                    }, []));
-                }
-                if (field.hasBlank) {
-                    sharedItemChildren.push(createElement('m', {}, []));
-                }
-            } else if (field.isDate) {
-                sharedItemsAttrs.containsSemiMixedTypes = '0';
-                sharedItemsAttrs.containsString = '0';
-                sharedItemsAttrs.containsDate = '1';
-                sharedItemsAttrs.containsNonDate = '0';
-                if (field.hasBlank) {
-                    sharedItemsAttrs.containsBlank = '1';
-                }
-                if (field.minDate) {
-                    sharedItemsAttrs.minDate = this._formatDate(field.minDate);
-                }
-                if (field.maxDate) {
-                    const maxDate = new Date(field.maxDate.getTime() + 24 * 60 * 60 * 1000);
-                    sharedItemsAttrs.maxDate = this._formatDate(maxDate);
-                }
-            } else if (field.isNumeric) {
-                // Numeric field - use "0"/"1" for boolean attributes as Excel expects
-                sharedItemsAttrs.containsSemiMixedTypes = '0';
-                sharedItemsAttrs.containsString = '0';
-                sharedItemsAttrs.containsNumber = '1';
-                if (field.hasBlank) {
-                    sharedItemsAttrs.containsBlank = '1';
-                }
-                // Check if all values are integers
-                if (field.minValue !== undefined && field.maxValue !== undefined) {
-                    const isInteger = Number.isInteger(field.minValue) && Number.isInteger(field.maxValue);
-                    if (isInteger) {
-                        sharedItemsAttrs.containsInteger = '1';
-                    }
-                    sharedItemsAttrs.minValue = this._formatNumber(field.minValue);
-                    sharedItemsAttrs.maxValue = this._formatNumber(field.maxValue);
-                }
-            } else if (field.hasBoolean) {
-                // Boolean-only field (no strings, no numbers)
-                if (field.hasBlank) {
-                    sharedItemsAttrs.containsBlank = '1';
-                }
-                sharedItemsAttrs.count = field.hasBlank ? '3' : '2';
-                sharedItemChildren.push(createElement('b', {
-                    v: '0'
-                }, []));
-                sharedItemChildren.push(createElement('b', {
-                    v: '1'
-                }, []));
-                if (field.hasBlank) {
-                    sharedItemChildren.push(createElement('m', {}, []));
-                }
-            } else if (field.hasBlank) {
-                // Field that only contains blanks
-                sharedItemsAttrs.containsBlank = '1';
-            }
-            const sharedItemsNode = createElement('sharedItems', sharedItemsAttrs, sharedItemChildren);
-            const cacheFieldAttrs = {
-                name: field.name,
-                numFmtId: String(field.numFmtId ?? 0)
-            };
-            return createElement('cacheField', cacheFieldAttrs, [
-                sharedItemsNode
-            ]);
-        });
-        const cacheFieldsNode = createElement('cacheFields', {
-            count: String(this._fields.length)
-        }, cacheFieldNodes);
-        const worksheetSourceNode = createElement('worksheetSource', {
-            ref: this._sourceRange,
-            sheet: this._sourceSheet
-        }, []);
-        const cacheSourceNode = createElement('cacheSource', {
-            type: 'worksheet'
-        }, [
-            worksheetSourceNode
-        ]);
-        // Build attributes - align with Excel expectations
-        const definitionAttrs = {
-            xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
-            'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
-            'r:id': recordsRelId
-        };
-        if (this._refreshOnLoad) {
-            definitionAttrs.refreshOnLoad = '1';
-        }
-        definitionAttrs.refreshedBy = 'User';
-        definitionAttrs.refreshedVersion = '8';
-        definitionAttrs.minRefreshableVersion = '3';
-        definitionAttrs.createdVersion = '8';
-        if (!this._saveData) {
-            definitionAttrs.saveData = '0';
-            definitionAttrs.recordCount = '0';
-        } else {
-            definitionAttrs.recordCount = String(this._recordCount);
+    delete(path) {
+        this._files.delete(path);
+        this._deleted.add(path);
+        if (this._entryNames) {
+            this._entryNames.delete(path);
         }
-        const definitionNode = createElement('pivotCacheDefinition', definitionAttrs, [
-            cacheSourceNode,
-            cacheFieldsNode
-        ]);
-        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
-            definitionNode
-        ])}`;
     }
-    /**
-   * Generate the pivotCacheRecords XML
-   */ toRecordsXml() {
-        const recordNodes = [];
-        for (const row of this._records){
-            const fieldNodes = [];
-            for(let colIdx = 0; colIdx < this._fields.length; colIdx++){
-                const value = colIdx < row.length ? row[colIdx] : null;
-                if (value === null || value === undefined) {
-                    // Missing value
-                    const blankIndex = this._blankItemIndexMap.get(colIdx);
-                    if (blankIndex !== undefined) {
-                        fieldNodes.push(createElement('x', {
-                            v: String(blankIndex)
-                        }, []));
-                    } else {
-                        fieldNodes.push(createElement('m', {}, []));
-                    }
-                } else if (typeof value === 'string') {
-                    // String value - use index into sharedItems via O(1) Map lookup
-                    const indexMap = this._sharedItemsIndexMap.get(colIdx);
-                    const idx = indexMap?.get(value);
-                    if (idx !== undefined) {
-                        fieldNodes.push(createElement('x', {
-                            v: String(idx)
-                        }, []));
-                    } else {
-                        // Direct string value (shouldn't happen if cache is built correctly)
-                        fieldNodes.push(createElement('s', {
-                            v: value
-                        }, []));
-                    }
-                } else if (typeof value === 'number') {
-                    if (this._fields[colIdx]?.isDate) {
-                        const d = this._excelSerialToDate(value);
-                        fieldNodes.push(createElement('d', {
-                            v: this._formatDate(d)
-                        }, []));
-                    } else {
-                        fieldNodes.push(createElement('n', {
-                            v: String(value)
-                        }, []));
-                    }
-                } else if (typeof value === 'boolean') {
-                    fieldNodes.push(createElement('b', {
-                        v: value ? '1' : '0'
-                    }, []));
-                } else if (value instanceof Date) {
-                    fieldNodes.push(createElement('d', {
-                        v: this._formatDate(value)
-                    }, []));
-                } else {
-                    // Unknown type, treat as missing
-                    fieldNodes.push(createElement('m', {}, []));
-                }
-            }
-            recordNodes.push(createElement('r', {}, fieldNodes));
-        }
-        const recordsNode = createElement('pivotCacheRecords', {
-            xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
-            'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
-            count: String(this._recordCount)
-        }, recordNodes);
-        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
-            recordsNode
-        ])}`;
+    getText(path) {
+        const data = this.get(path);
+        if (!data) return undefined;
+        return fflate.strFromU8(data);
     }
-    _formatDate(value) {
-        return value.toISOString().replace(/\.\d{3}Z$/, '');
+    setText(path, content) {
+        this.set(path, fflate.strToU8(content));
     }
-    _formatNumber(value) {
-        if (Number.isInteger(value)) {
-            return String(value);
+    async toFiles() {
+        const unzipped = fflate.unzipSync(this._data);
+        const files = new Map(Object.entries(unzipped));
+        for (const path of this._deleted){
+            files.delete(path);
         }
-        if (Math.abs(value) >= 1000000) {
-            return value.toFixed(16).replace(/0+$/, '').replace(/\.$/, '');
+        for (const [path, content] of this._files){
+            files.set(path, content);
         }
-        return String(value);
+        return files;
     }
-    _excelSerialToDate(serial) {
-        // Excel epoch: December 31, 1899
-        const EXCEL_EPOCH = Date.UTC(1899, 11, 31);
-        const MS_PER_DAY = 24 * 60 * 60 * 1000;
-        const adjusted = serial >= 60 ? serial - 1 : serial;
-        const ms = Math.round(adjusted * MS_PER_DAY);
-        return new Date(EXCEL_EPOCH + ms);
+    _ensureIndex() {
+        if (this._entryNames) return;
+        const names = new Set();
+        fflate.unzipSync(this._data, {
+            filter: (file)=>{
+                names.add(file.name);
+                return false;
+            }
+        });
+        this._entryNames = names;
     }
 }
-
+const createZipStore = ()=>{
+    return new EagerZipStore(new Map());
+};
 /**
  * Reads a ZIP file and returns a map of path -> content
  * @param data - ZIP file as Uint8Array
  * @returns Promise resolving to a map of file paths to contents
- */ const readZip = (data)=>{
+ */ const readZip = (data, options)=>{
+    const lazy = options?.lazy ?? false;
+    if (lazy) {
+        return Promise.resolve(new LazyZipStore(data));
+    }
     const isBun = typeof globalThis.Bun !== 'undefined';
     if (isBun) {
         try {
@@ -4024,7 +3967,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             for (const [path, content] of Object.entries(result)){
                 files.set(path, content);
             }
-            return Promise.resolve(files);
+            return Promise.resolve(new EagerZipStore(files));
         } catch (error) {
             return Promise.reject(error);
         }
@@ -4039,7 +3982,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             for (const [path, content] of Object.entries(result)){
                 files.set(path, content);
             }
-            resolve(files);
+            resolve(new EagerZipStore(files));
         });
     });
 };
@@ -4047,9 +3990,10 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
  * Creates a ZIP file from a map of path -> content
  * @param files - Map of file paths to contents
  * @returns Promise resolving to ZIP file as Uint8Array
- */ const writeZip = (files)=>{
+ */ const writeZip = async (files)=>{
+    const resolved = await files.toFiles();
     const zipData = {};
-    for (const [path, content] of files){
+    for (const [path, content] of resolved){
         zipData[path] = content;
     }
     const isBun = typeof globalThis.Bun !== 'undefined';
@@ -4073,49 +4017,53 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
 /**
  * Reads a file from the ZIP as a UTF-8 string
  */ const readZipText = (files, path)=>{
-    const data = files.get(path);
-    if (!data) return undefined;
-    return fflate.strFromU8(data);
+    return files.getText(path);
 };
 /**
  * Writes a UTF-8 string to the ZIP files map
  */ const writeZipText = (files, path, content)=>{
-    files.set(path, fflate.strToU8(content));
+    files.setText(path, content);
 };
 
 /**
  * Represents an Excel workbook (.xlsx file)
  */ class Workbook {
     constructor(){
-        this._files = new Map();
+        this._files = createZipStore();
         this._sheets = new Map();
         this._sheetDefs = [];
         this._relationships = [];
+        this._sharedStrings = null;
+        this._styles = null;
+        this._sharedStringsXml = null;
+        this._stylesXml = null;
+        this._lazy = true;
         this._dirty = false;
-        // Pivot table support
-        this._pivotTables = [];
-        this._pivotCaches = [];
-        this._nextCacheId = 5;
-        this._nextCacheFileIndex = 1;
         // Table support
         this._nextTableId = 1;
+        // Pivot table support
+        this._pivotTables = [];
+        this._nextPivotTableId = 1;
+        this._nextPivotCacheId = 1;
         // Date serialization handling
         this._dateHandling = 'jsDate';
         this._locale = 'fr-FR';
-        this._sharedStrings = new SharedStrings();
-        this._styles = Styles.createDefault();
+    // Lazy init
     }
     /**
    * Load a workbook from a file path
-   */ static async fromFile(path) {
+   */ static async fromFile(path, options = {}) {
         const data = await promises.readFile(path);
-        return Workbook.fromBuffer(new Uint8Array(data));
+        return Workbook.fromBuffer(new Uint8Array(data), options);
     }
     /**
    * Load a workbook from a buffer
-   */ static async fromBuffer(data) {
+   */ static async fromBuffer(data, options = {}) {
         const workbook = new Workbook();
-        workbook._files = await readZip(data);
+        workbook._lazy = options.lazy ?? true;
+        workbook._files = await readZip(data, {
+            lazy: workbook._lazy
+        });
         // Parse workbook.xml for sheet definitions
         const workbookXml = readZipText(workbook._files, 'xl/workbook.xml');
         if (workbookXml) {
@@ -4127,15 +4075,9 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             workbook._parseRelationships(relsXml);
         }
         // Parse shared strings
-        const sharedStringsXml = readZipText(workbook._files, 'xl/sharedStrings.xml');
-        if (sharedStringsXml) {
-            workbook._sharedStrings = SharedStrings.parse(sharedStringsXml);
-        }
-        // Parse styles
-        const stylesXml = readZipText(workbook._files, 'xl/styles.xml');
-        if (stylesXml) {
-            workbook._styles = Styles.parse(stylesXml);
-        }
+        // Store shared strings/styles XML for lazy parse
+        workbook._sharedStringsXml = readZipText(workbook._files, 'xl/sharedStrings.xml') ?? null;
+        workbook._stylesXml = readZipText(workbook._files, 'xl/styles.xml') ?? null;
         return workbook;
     }
     /**
@@ -4143,6 +4085,9 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
    */ static create() {
         const workbook = new Workbook();
         workbook._dirty = true;
+        workbook._lazy = false;
+        workbook._sharedStrings = new SharedStrings();
+        workbook._styles = Styles.createDefault();
         return workbook;
     }
     /**
@@ -4158,11 +4103,25 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     /**
    * Get shared strings table
    */ get sharedStrings() {
+        if (!this._sharedStrings) {
+            if (this._sharedStringsXml) {
+                this._sharedStrings = SharedStrings.parse(this._sharedStringsXml);
+            } else {
+                this._sharedStrings = new SharedStrings();
+            }
+        }
         return this._sharedStrings;
     }
     /**
    * Get styles
    */ get styles() {
+        if (!this._styles) {
+            if (this._stylesXml) {
+                this._styles = Styles.parse(this._stylesXml);
+            } else {
+                this._styles = Styles.createDefault();
+            }
+        }
         return this._styles;
     }
     /**
@@ -4193,6 +4152,72 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         return this._nextTableId++;
     }
     /**
+   * Get all pivot tables in the workbook.
+   */ get pivotTables() {
+        return [
+            ...this._pivotTables
+        ];
+    }
+    /**
+   * Create a new pivot table.
+   */ createPivotTable(config) {
+        if (!config.name || config.name.trim().length === 0) {
+            throw new Error('Pivot table name is required');
+        }
+        if (this._pivotTables.some((pivot)=>pivot.name === config.name)) {
+            throw new Error(`Pivot table name already exists: ${config.name}`);
+        }
+        const sourceRef = parseSheetRange(config.source);
+        const targetRef = parseSheetAddress(config.target);
+        const sourceSheet = this.sheet(sourceRef.sheet);
+        this.sheet(targetRef.sheet);
+        const sourceRange = this._normalizeRange(sourceRef.range);
+        if (sourceRange.start.row >= sourceRange.end.row) {
+            throw new Error('Pivot source range must include a header row and at least one data row');
+        }
+        const fields = this._extractPivotFields(sourceSheet, sourceRange);
+        const cacheId = this._nextPivotCacheId++;
+        const pivotId = this._nextPivotTableId++;
+        const cachePartIndex = this._pivotTables.length + 1;
+        const pivot = new PivotTable(this, config, sourceRef.sheet, sourceSheet, sourceRange, targetRef.sheet, targetRef.address, cacheId, pivotId, cachePartIndex, fields);
+        this._pivotTables.push(pivot);
+        this._dirty = true;
+        return pivot;
+    }
+    _extractPivotFields(sourceSheet, sourceRange) {
+        const fields = [];
+        const seen = new Set();
+        for(let col = sourceRange.start.col; col <= sourceRange.end.col; col++){
+            const headerCell = sourceSheet.getCellIfExists(sourceRange.start.row, col);
+            const rawHeader = headerCell?.value;
+            const name = rawHeader == null ? `Column${col - sourceRange.start.col + 1}` : String(rawHeader).trim();
+            if (!name) {
+                throw new Error(`Pivot source header is empty at column ${col + 1}`);
+            }
+            if (seen.has(name)) {
+                throw new Error(`Duplicate pivot source header: ${name}`);
+            }
+            seen.add(name);
+            fields.push({
+                name,
+                sourceCol: col
+            });
+        }
+        return fields;
+    }
+    _normalizeRange(range) {
+        return {
+            start: {
+                row: Math.min(range.start.row, range.end.row),
+                col: Math.min(range.start.col, range.end.col)
+            },
+            end: {
+                row: Math.max(range.start.row, range.end.row),
+                col: Math.max(range.start.col, range.end.col)
+            }
+        };
+    }
+    /**
    * Get a worksheet by name or index
    */ sheet(nameOrIndex) {
         let def;
@@ -4216,7 +4241,9 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             const sheetPath = `xl/${rel.target}`;
             const sheetXml = readZipText(this._files, sheetPath);
             if (sheetXml) {
-                worksheet.parse(sheetXml);
+                worksheet.parse(sheetXml, {
+                    lazy: this._lazy
+                });
             }
         }
         this._sheets.set(def.name, worksheet);
@@ -4527,100 +4554,6 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         return String(value);
     }
     /**
-   * Create a pivot table from source data.
-   *
-   * @param config - Pivot table configuration
-   * @returns PivotTable instance for fluent configuration
-   *
-   * @example
-   * ```typescript
-   * const pivot = wb.createPivotTable({
-   *   name: 'SalesPivot',
-   *   source: 'DataSheet!A1:D100',
-   *   target: 'PivotSheet!A3',
-   * });
-   *
-   * pivot
-   *   .addRowField('Region')
-   *   .addColumnField('Product')
-   *   .addValueField('Sales', 'sum', 'Total Sales');
-   * ```
-   */ createPivotTable(config) {
-        this._dirty = true;
-        // Parse source reference (Sheet!Range)
-        const { sheetName: sourceSheet, range: sourceRange } = this._parseSheetRef(config.source);
-        // Parse target reference
-        const { sheetName: targetSheet, range: targetCell } = this._parseSheetRef(config.target);
-        // Ensure target sheet exists
-        if (!this._sheetDefs.some((s)=>s.name === targetSheet)) {
-            this.addSheet(targetSheet);
-        }
-        // Parse target cell address
-        const targetAddr = parseAddress(targetCell);
-        // Get source worksheet and extract data
-        const sourceWs = this.sheet(sourceSheet);
-        const { headers, data } = this._extractSourceData(sourceWs, sourceRange);
-        // Create pivot cache
-        const cacheId = this._nextCacheId++;
-        const cacheFileIndex = this._nextCacheFileIndex++;
-        const cache = new PivotCache(cacheId, sourceSheet, sourceRange, cacheFileIndex);
-        cache.setStyles(this._styles);
-        cache.buildFromData(headers, data);
-        // refreshOnLoad defaults to true; only disable if explicitly set to false
-        if (config.refreshOnLoad === false) {
-            cache.refreshOnLoad = false;
-        }
-        // saveData defaults to true; only disable if explicitly set to false
-        if (config.saveData === false) {
-            cache.saveData = false;
-        }
-        this._pivotCaches.push(cache);
-        // Create pivot table
-        const pivotTableIndex = this._pivotTables.length + 1;
-        const pivotTable = new PivotTable(config.name, cache, targetSheet, targetCell, targetAddr.row + 1, targetAddr.col, pivotTableIndex, cacheFileIndex);
-        // Set styles reference for number format resolution
-        pivotTable.setStyles(this._styles);
-        this._pivotTables.push(pivotTable);
-        return pivotTable;
-    }
-    /**
-   * Parse a sheet reference like "Sheet1!A1:D100" into sheet name and range
-   */ _parseSheetRef(ref) {
-        const match = ref.match(/^(.+?)!(.+)$/);
-        if (!match) {
-            throw new Error(`Invalid reference format: ${ref}. Expected "SheetName!Range"`);
-        }
-        return {
-            sheetName: match[1],
-            range: match[2]
-        };
-    }
-    /**
-   * Extract headers and data from a source range
-   */ _extractSourceData(sheet, rangeStr) {
-        const range = parseRange(rangeStr);
-        const headers = [];
-        const data = [];
-        // First row is headers
-        for(let col = range.start.col; col <= range.end.col; col++){
-            const cell = sheet.cell(toAddress(range.start.row, col));
-            headers.push(String(cell.value ?? `Column${col + 1}`));
-        }
-        // Remaining rows are data
-        for(let row = range.start.row + 1; row <= range.end.row; row++){
-            const rowData = [];
-            for(let col = range.start.col; col <= range.end.col; col++){
-                const cell = sheet.cell(toAddress(row, col));
-                rowData.push(cell.value);
-            }
-            data.push(rowData);
-        }
-        return {
-            headers,
-            data
-        };
-    }
-    /**
    * Save the workbook to a file
    */ async toFile(path) {
         const buffer = await this.toBuffer();
@@ -4678,20 +4611,28 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
     _updateFiles() {
         const relationshipInfo = this._buildRelationshipInfo();
         // Update workbook.xml
-        this._updateWorkbookXml(relationshipInfo.pivotCacheRelIds);
+        this._updateWorkbookXml(relationshipInfo.pivotCacheRelByTarget);
         // Update relationships
         this._updateRelationshipsXml(relationshipInfo.relNodes);
         // Update content types
         this._updateContentTypes();
         // Update shared strings if modified
-        if (this._sharedStrings.dirty || this._sharedStrings.count > 0) {
-            writeZipText(this._files, 'xl/sharedStrings.xml', this._sharedStrings.toXml());
+        if (this._sharedStrings) {
+            if (this._sharedStrings.dirty || this._sharedStrings.count > 0) {
+                writeZipText(this._files, 'xl/sharedStrings.xml', this._sharedStrings.toXml());
+            }
+        } else if (this._sharedStringsXml) {
+            writeZipText(this._files, 'xl/sharedStrings.xml', this._sharedStringsXml);
         }
         // Update styles if modified or if file doesn't exist yet
-        if (this._styles.dirty || this._dirty || !this._files.has('xl/styles.xml')) {
-            writeZipText(this._files, 'xl/styles.xml', this._styles.toXml());
+        if (this._styles) {
+            if (this._styles.dirty || this._dirty || !this._files.has('xl/styles.xml')) {
+                writeZipText(this._files, 'xl/styles.xml', this._styles.toXml());
+            }
+        } else if (this._stylesXml) {
+            writeZipText(this._files, 'xl/styles.xml', this._stylesXml);
         }
-        // Update worksheets (needed for pivot table targets)
+        // Update worksheets
         for (const [name, worksheet] of this._sheets){
             if (worksheet.dirty || this._dirty || worksheet.tables.length > 0) {
                 const def = this._sheetDefs.find((s)=>s.name === name);
@@ -4704,15 +4645,13 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 }
             }
         }
-        // Update pivot tables
-        if (this._pivotTables.length > 0) {
-            this._updatePivotTableFiles();
-        }
         // Update tables (sets table rel IDs for tableParts)
         this._updateTableFiles();
+        // Update pivot tables (sets pivot rel IDs for pivotTableParts)
+        this._updatePivotFiles();
         // Update worksheets to align tableParts with relationship IDs
         for (const [name, worksheet] of this._sheets){
-            if (worksheet.dirty || this._dirty || worksheet.tables.length > 0) {
+            if (worksheet.dirty || this._dirty || worksheet.tables.length > 0 || this._pivotTables.length > 0) {
                 const def = this._sheetDefs.find((s)=>s.name === name);
                 if (def) {
                     const rel = this._relationships.find((r)=>r.id === def.rId);
@@ -4724,7 +4663,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             }
         }
     }
-    _updateWorkbookXml(pivotCacheRelIds) {
+    _updateWorkbookXml(pivotCacheRelByTarget) {
         const sheetNodes = this._sheetDefs.map((def)=>createElement('sheet', {
                 name: def.name,
                 sheetId: String(def.sheetId),
@@ -4734,19 +4673,20 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         const children = [
             sheetsNode
         ];
-        // Add pivot caches if any
-        if (this._pivotCaches.length > 0) {
-            const pivotCacheNodes = this._pivotCaches.map((cache)=>{
-                const cacheRelId = pivotCacheRelIds.get(cache.cacheId);
-                if (!cacheRelId) {
-                    throw new Error(`Missing pivot cache relationship ID for cache ${cache.cacheId}`);
-                }
-                return createElement('pivotCache', {
-                    cacheId: String(cache.cacheId),
-                    'r:id': cacheRelId
-                }, []);
-            });
-            children.push(createElement('pivotCaches', {}, pivotCacheNodes));
+        if (this._pivotTables.length > 0) {
+            const pivotCacheNodes = [];
+            for (const pivot of this._pivotTables){
+                const target = `pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`;
+                const relId = pivotCacheRelByTarget.get(target);
+                if (!relId) continue;
+                pivotCacheNodes.push(createElement('pivotCache', {
+                    cacheId: String(pivot.cacheId),
+                    'r:id': relId
+                }, []));
+            }
+            if (pivotCacheNodes.length > 0) {
+                children.push(createElement('pivotCaches', {}, pivotCacheNodes));
+            }
         }
         const workbookNode = createElement('workbook', {
             xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
@@ -4772,6 +4712,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 Type: rel.type,
                 Target: rel.target
             }, []));
+        const pivotCacheRelByTarget = new Map();
         const reservedRelIds = new Set(relNodes.map((node)=>getAttr(node, 'Id') || '').filter(Boolean));
         let nextRelId = Math.max(0, ...this._relationships.map((r)=>parseInt(r.id.replace('rId', ''), 10) || 0)) + 1;
         const allocateRelId = ()=>{
@@ -4784,7 +4725,8 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             return id;
         };
         // Add shared strings relationship if needed
-        if (this._sharedStrings.count > 0) {
+        const shouldIncludeSharedStrings = (this._sharedStrings?.count ?? 0) > 0 || this._sharedStringsXml !== null;
+        if (shouldIncludeSharedStrings) {
             const hasSharedStrings = this._relationships.some((r)=>r.type === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings');
             if (!hasSharedStrings) {
                 relNodes.push(createElement('Relationship', {
@@ -4803,23 +4745,32 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 Target: 'styles.xml'
             }, []));
         }
-        // Add pivot cache relationships
-        const pivotCacheRelIds = new Map();
-        for (const cache of this._pivotCaches){
-            const id = allocateRelId();
-            pivotCacheRelIds.set(cache.cacheId, id);
-            relNodes.push(createElement('Relationship', {
-                Id: id,
-                Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
-                Target: `pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`
-            }, []));
+        for (const pivot of this._pivotTables){
+            const target = `pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`;
+            const hasPivotCacheRel = relNodes.some((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition' && getAttr(node, 'Target') === target);
+            if (!hasPivotCacheRel) {
+                const id = allocateRelId();
+                pivotCacheRelByTarget.set(target, id);
+                relNodes.push(createElement('Relationship', {
+                    Id: id,
+                    Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
+                    Target: target
+                }, []));
+            } else {
+                const existing = relNodes.find((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition' && getAttr(node, 'Target') === target);
+                const existingId = existing ? getAttr(existing, 'Id') : undefined;
+                if (existingId) {
+                    pivotCacheRelByTarget.set(target, existingId);
+                }
+            }
         }
         return {
             relNodes,
-            pivotCacheRelIds
+            pivotCacheRelByTarget
         };
     }
     _updateContentTypes() {
+        const shouldIncludeSharedStrings = (this._sharedStrings?.count ?? 0) > 0 || this._sharedStringsXml !== null;
         const types = [
             createElement('Default', {
                 Extension: 'rels',
@@ -4839,7 +4790,7 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             }, [])
         ];
         // Add shared strings if present
-        if (this._sharedStrings.count > 0) {
+        if (shouldIncludeSharedStrings) {
             types.push(createElement('Override', {
                 PartName: '/xl/sharedStrings.xml',
                 ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
@@ -4855,24 +4806,6 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 }, []));
             }
         }
-        // Add pivot cache definitions and records
-        for (const cache of this._pivotCaches){
-            types.push(createElement('Override', {
-                PartName: `/xl/pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`,
-                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml'
-            }, []));
-            types.push(createElement('Override', {
-                PartName: `/xl/pivotCache/pivotCacheRecords${cache.fileIndex}.xml`,
-                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml'
-            }, []));
-        }
-        // Add pivot tables
-        for (const pivotTable of this._pivotTables){
-            types.push(createElement('Override', {
-                PartName: `/xl/pivotTables/pivotTable${pivotTable.index}.xml`,
-                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml'
-            }, []));
-        }
         // Add tables
         let tableIndex = 1;
         for (const def of this._sheetDefs){
@@ -4887,6 +4820,21 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 }
             }
         }
+        // Add pivot caches and pivot tables
+        for (const pivot of this._pivotTables){
+            types.push(createElement('Override', {
+                PartName: `/xl/pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`,
+                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml'
+            }, []));
+            types.push(createElement('Override', {
+                PartName: `/xl/pivotCache/pivotCacheRecords${pivot.cachePartIndex}.xml`,
+                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml'
+            }, []));
+            types.push(createElement('Override', {
+                PartName: `/xl/pivotTables/pivotTable${pivot.pivotId}.xml`,
+                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml'
+            }, []));
+        }
         const existingTypesXml = readZipText(this._files, '[Content_Types].xml');
         const existingKeys = new Set(types.map((t)=>{
             if ('Default' in t) {
@@ -4942,66 +4890,35 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         }
     }
     /**
-   * Generate all pivot table related files
-   */ _updatePivotTableFiles() {
-        // Track which sheets have pivot tables for their .rels files
-        const sheetPivotTables = new Map();
-        for (const pivotTable of this._pivotTables){
-            const sheetName = pivotTable.targetSheet;
-            if (!sheetPivotTables.has(sheetName)) {
-                sheetPivotTables.set(sheetName, []);
+   * Generate all table related files
+   */ _updateTableFiles() {
+        // Collect all tables with their global indices
+        let globalTableIndex = 1;
+        const sheetTables = new Map();
+        for (const def of this._sheetDefs){
+            const worksheet = this._sheets.get(def.name);
+            if (!worksheet) continue;
+            const tables = worksheet.tables;
+            if (tables.length === 0) continue;
+            const tableInfos = [];
+            for (const table of tables){
+                tableInfos.push({
+                    table,
+                    globalIndex: globalTableIndex
+                });
+                globalTableIndex++;
             }
-            sheetPivotTables.get(sheetName).push(pivotTable);
-        }
-        // Generate pivot cache files
-        for(let i = 0; i < this._pivotCaches.length; i++){
-            const cache = this._pivotCaches[i];
-            // Pivot cache definition
-            const definitionPath = `xl/pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`;
-            writeZipText(this._files, definitionPath, cache.toDefinitionXml('rId1'));
-            // Pivot cache records
-            const recordsPath = `xl/pivotCache/pivotCacheRecords${cache.fileIndex}.xml`;
-            writeZipText(this._files, recordsPath, cache.toRecordsXml());
-            // Pivot cache definition relationships (link to records)
-            const cacheRelsPath = `xl/pivotCache/_rels/pivotCacheDefinition${cache.fileIndex}.xml.rels`;
-            const cacheRels = createElement('Relationships', {
-                xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
-            }, [
-                createElement('Relationship', {
-                    Id: 'rId1',
-                    Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords',
-                    Target: `pivotCacheRecords${cache.fileIndex}.xml`
-                }, [])
-            ]);
-            writeZipText(this._files, cacheRelsPath, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
-                cacheRels
-            ])}`);
+            sheetTables.set(def.name, tableInfos);
         }
-        // Generate pivot table files
-        for(let i = 0; i < this._pivotTables.length; i++){
-            const pivotTable = this._pivotTables[i];
-            const ptIdx = pivotTable.index;
-            // Pivot table definition
-            const ptPath = `xl/pivotTables/pivotTable${ptIdx}.xml`;
-            writeZipText(this._files, ptPath, pivotTable.toXml());
-            // Pivot table relationships (link to cache definition)
-            const cacheIdx = pivotTable.cacheFileIndex;
-            const ptRelsPath = `xl/pivotTables/_rels/pivotTable${ptIdx}.xml.rels`;
-            const ptRels = createElement('Relationships', {
-                xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
-            }, [
-                createElement('Relationship', {
-                    Id: 'rId1',
-                    Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
-                    Target: `../pivotCache/pivotCacheDefinition${cacheIdx}.xml`
-                }, [])
-            ]);
-            writeZipText(this._files, ptRelsPath, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
-                ptRels
-            ])}`);
+        // Generate table files
+        for (const [, tableInfos] of sheetTables){
+            for (const { table, globalIndex } of tableInfos){
+                const tablePath = `xl/tables/table${globalIndex}.xml`;
+                writeZipText(this._files, tablePath, table.toXml());
+            }
         }
-        // Generate worksheet relationships for pivot tables
-        for (const [sheetName, pivotTables] of sheetPivotTables){
+        // Generate worksheet relationships for tables
+        for (const [sheetName, tableInfos] of sheetTables){
             const def = this._sheetDefs.find((s)=>s.name === sheetName);
             if (!def) continue;
             const rel = this._relationships.find((r)=>r.id === def.rId);
@@ -5009,11 +4926,13 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
             // Extract sheet file name from target path
             const sheetFileName = rel.target.split('/').pop();
             const sheetRelsPath = `xl/worksheets/_rels/${sheetFileName}.rels`;
+            // Check if there are already pivot table relationships for this sheet
             const existingRelsXml = readZipText(this._files, sheetRelsPath);
-            let relNodes = [];
             let nextRelId = 1;
+            const relNodes = [];
             const reservedRelIds = new Set();
             if (existingRelsXml) {
+                // Parse existing rels and find max rId
                 const parsed = parseXml(existingRelsXml);
                 const relsElement = findElement(parsed, 'Relationships');
                 if (relsElement) {
@@ -5042,16 +4961,29 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 reservedRelIds.add(id);
                 return id;
             };
-            for (const pt of pivotTables){
-                const target = `../pivotTables/pivotTable${pt.index}.xml`;
-                const existing = relNodes.some((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable' && getAttr(node, 'Target') === target);
-                if (existing) continue;
+            // Add table relationships
+            const tableRelIds = [];
+            for (const { globalIndex } of tableInfos){
+                const target = `../tables/table${globalIndex}.xml`;
+                const existing = relNodes.some((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' && getAttr(node, 'Target') === target);
+                if (existing) {
+                    const existingRel = relNodes.find((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' && getAttr(node, 'Target') === target);
+                    const existingId = existingRel ? getAttr(existingRel, 'Id') : undefined;
+                    tableRelIds.push(existingId ?? allocateRelId());
+                    continue;
+                }
+                const id = allocateRelId();
+                tableRelIds.push(id);
                 relNodes.push(createElement('Relationship', {
-                    Id: allocateRelId(),
-                    Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable',
+                    Id: id,
+                    Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table',
                     Target: target
                 }, []));
             }
+            const worksheet = this._sheets.get(sheetName);
+            if (worksheet) {
+                worksheet.setTableRelIds(tableRelIds);
+            }
             const sheetRels = createElement('Relationships', {
                 xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
             }, relNodes);
@@ -5061,54 +4993,45 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
         }
     }
     /**
-   * Generate all table related files
-   */ _updateTableFiles() {
-        // Collect all tables with their global indices
-        let globalTableIndex = 1;
-        const sheetTables = new Map();
-        for (const def of this._sheetDefs){
-            const worksheet = this._sheets.get(def.name);
-            if (!worksheet) continue;
-            const tables = worksheet.tables;
-            if (tables.length === 0) continue;
-            const tableInfos = [];
-            for (const table of tables){
-                tableInfos.push({
-                    table,
-                    globalIndex: globalTableIndex
-                });
-                globalTableIndex++;
-            }
-            sheetTables.set(def.name, tableInfos);
-        }
-        // Generate table files
-        for (const [, tableInfos] of sheetTables){
-            for (const { table, globalIndex } of tableInfos){
-                const tablePath = `xl/tables/table${globalIndex}.xml`;
-                writeZipText(this._files, tablePath, table.toXml());
-            }
+   * Generate pivot cache/table parts and worksheet relationships.
+   */ _updatePivotFiles() {
+        if (this._pivotTables.length === 0) {
+            return;
         }
-        // Generate worksheet relationships for tables
-        for (const [sheetName, tableInfos] of sheetTables){
+        for (const pivot of this._pivotTables){
+            const pivotParts = pivot.buildPivotPartsXml();
+            const pivotCachePath = `xl/pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`;
+            writeZipText(this._files, pivotCachePath, pivotParts.cacheDefinitionXml);
+            const pivotCacheRecordsPath = `xl/pivotCache/pivotCacheRecords${pivot.cachePartIndex}.xml`;
+            writeZipText(this._files, pivotCacheRecordsPath, pivotParts.cacheRecordsXml);
+            const pivotCacheRelsPath = `xl/pivotCache/_rels/pivotCacheDefinition${pivot.cachePartIndex}.xml.rels`;
+            writeZipText(this._files, pivotCacheRelsPath, pivotParts.cacheRelsXml);
+            const pivotTablePath = `xl/pivotTables/pivotTable${pivot.pivotId}.xml`;
+            writeZipText(this._files, pivotTablePath, pivotParts.pivotTableXml);
+        }
+        const pivotsBySheet = new Map();
+        for (const pivot of this._pivotTables){
+            const existing = pivotsBySheet.get(pivot.targetSheetName) ?? [];
+            existing.push(pivot);
+            pivotsBySheet.set(pivot.targetSheetName, existing);
+        }
+        for (const [sheetName, pivots] of pivotsBySheet){
             const def = this._sheetDefs.find((s)=>s.name === sheetName);
             if (!def) continue;
             const rel = this._relationships.find((r)=>r.id === def.rId);
             if (!rel) continue;
-            // Extract sheet file name from target path
             const sheetFileName = rel.target.split('/').pop();
+            if (!sheetFileName) continue;
             const sheetRelsPath = `xl/worksheets/_rels/${sheetFileName}.rels`;
-            // Check if there are already pivot table relationships for this sheet
             const existingRelsXml = readZipText(this._files, sheetRelsPath);
             let nextRelId = 1;
             const relNodes = [];
             const reservedRelIds = new Set();
             if (existingRelsXml) {
-                // Parse existing rels and find max rId
                 const parsed = parseXml(existingRelsXml);
                 const relsElement = findElement(parsed, 'Relationships');
                 if (relsElement) {
-                    const existingRelNodes = getChildren(relsElement, 'Relationships');
-                    for (const relNode of existingRelNodes){
+                    for (const relNode of getChildren(relsElement, 'Relationships')){
                         if ('Relationship' in relNode) {
                             relNodes.push(relNode);
                             const id = getAttr(relNode, 'Id');
@@ -5132,28 +5055,26 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
                 reservedRelIds.add(id);
                 return id;
             };
-            // Add table relationships
-            const tableRelIds = [];
-            for (const { globalIndex } of tableInfos){
-                const target = `../tables/table${globalIndex}.xml`;
-                const existing = relNodes.some((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' && getAttr(node, 'Target') === target);
+            const pivotRelIds = [];
+            for (const pivot of pivots){
+                const target = `../pivotTables/pivotTable${pivot.pivotId}.xml`;
+                const existing = relNodes.find((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable' && getAttr(node, 'Target') === target);
                 if (existing) {
-                    const existingRel = relNodes.find((node)=>getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' && getAttr(node, 'Target') === target);
-                    const existingId = existingRel ? getAttr(existingRel, 'Id') : undefined;
-                    tableRelIds.push(existingId ?? allocateRelId());
+                    const existingId = getAttr(existing, 'Id');
+                    pivotRelIds.push(existingId ?? allocateRelId());
                     continue;
                 }
                 const id = allocateRelId();
-                tableRelIds.push(id);
+                pivotRelIds.push(id);
                 relNodes.push(createElement('Relationship', {
                     Id: id,
-                    Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table',
+                    Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable',
                     Target: target
                 }, []));
             }
             const worksheet = this._sheets.get(sheetName);
             if (worksheet) {
-                worksheet.setTableRelIds(tableRelIds);
+                worksheet.setPivotTableRelIds(pivotRelIds);
             }
             const sheetRels = createElement('Relationships', {
                 xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
@@ -5166,7 +5087,6 @@ const shouldEscapeXmlAttr = (tagName, attrName)=>{
 }
 
 exports.Cell = Cell;
-exports.PivotCache = PivotCache;
 exports.PivotTable = PivotTable;
 exports.Range = Range;
 exports.SharedStrings = SharedStrings;
@@ -5176,5 +5096,7 @@ exports.Workbook = Workbook;
 exports.Worksheet = Worksheet;
 exports.parseAddress = parseAddress;
 exports.parseRange = parseRange;
+exports.parseSheetAddress = parseSheetAddress;
+exports.parseSheetRange = parseSheetRange;
 exports.toAddress = toAddress;
 exports.toRange = toRange;