@niicojs/excel 0.2.6 → 0.3.0

package/dist/index.js

@@ -38,8 +38,10 @@ import { unzip, strFromU8, zip, strToU8 } from 'fflate';
     if (!match) {
         throw new Error(`Invalid cell address: ${address}`);
     }
+    const rowNumber = +match[2];
+    if (rowNumber <= 0) throw new Error(`Invalid cell address: ${address}`);
     const col = letterToCol(match[1].toUpperCase());
-    const row = parseInt(match[2], 10) - 1; // Convert to 0-based
+    const row = rowNumber - 1; // Convert to 0-based
     return {
         row,
         col
@@ -433,12 +435,23 @@ _computedKey = Symbol.iterator;
     /**
    * Get all values in the range as a 2D array
    */ get values() {
+        return this.getValues();
+    }
+    /**
+   * Get all values in the range as a 2D array with options
+   */ getValues(options = {}) {
+        const { createMissing = true } = options;
         const result = [];
         for(let r = this._range.start.row; r <= this._range.end.row; r++){
             const row = [];
             for(let c = this._range.start.col; c <= this._range.end.col; c++){
-                const cell = this._worksheet.cell(r, c);
-                row.push(cell.value);
+                if (createMissing) {
+                    const cell = this._worksheet.cell(r, c);
+                    row.push(cell.value);
+                } else {
+                    const cell = this._worksheet.getCellIfExists(r, c);
+                    row.push(cell?.value ?? null);
+                }
             }
             result.push(row);
         }
@@ -602,6 +615,322 @@ const builder = new XMLBuilder(builderOptions);
     };
 };
 
+/**
+ * Maps table total function names to SUBTOTAL function numbers
+ * SUBTOTAL uses 101-111 for functions that ignore hidden values
+ */ const TOTAL_FUNCTION_NUMBERS = {
+    average: 101,
+    count: 102,
+    countNums: 103,
+    max: 104,
+    min: 105,
+    stdDev: 107,
+    sum: 109,
+    var: 110,
+    none: 0
+};
+/**
+ * Maps table total function names to XML attribute values
+ */ const TOTAL_FUNCTION_NAMES = {
+    average: 'average',
+    count: 'count',
+    countNums: 'countNums',
+    max: 'max',
+    min: 'min',
+    stdDev: 'stdDev',
+    sum: 'sum',
+    var: 'var',
+    none: 'none'
+};
+/**
+ * Represents an Excel Table (ListObject) with auto-filter, banded styling, and total row.
+ */ class Table {
+    constructor(worksheet, config, tableId){
+        this._columns = [];
+        this._dirty = true;
+        this._worksheet = worksheet;
+        this._name = config.name;
+        this._displayName = config.name;
+        this._range = parseRange(config.range);
+        this._baseRange = {
+            start: {
+                ...this._range.start
+            },
+            end: {
+                ...this._range.end
+            }
+        };
+        this._totalRow = config.totalRow === true; // Default false
+        this._autoFilter = true; // Tables have auto-filter by default
+        this._headerRow = config.headerRow !== false;
+        this._id = tableId;
+        // Expand range to include total row if enabled
+        if (this._totalRow) {
+            this._range.end.row++;
+        }
+        // Set default style
+        this._style = {
+            name: config.style?.name ?? 'TableStyleMedium2',
+            showRowStripes: config.style?.showRowStripes !== false,
+            showColumnStripes: config.style?.showColumnStripes === true,
+            showFirstColumn: config.style?.showFirstColumn === true,
+            showLastColumn: config.style?.showLastColumn === true
+        };
+        // Extract column names from worksheet headers
+        this._extractColumns();
+    }
+    /**
+   * Get the table name
+   */ get name() {
+        return this._name;
+    }
+    /**
+   * Get the table display name
+   */ get displayName() {
+        return this._displayName;
+    }
+    /**
+   * Get the table ID
+   */ get id() {
+        return this._id;
+    }
+    /**
+   * Get the worksheet this table belongs to
+   */ get worksheet() {
+        return this._worksheet;
+    }
+    /**
+   * Get the table range address string
+   */ get range() {
+        return toRange(this._range);
+    }
+    /**
+   * Get the base range excluding total row
+   */ get baseRange() {
+        return toRange(this._baseRange);
+    }
+    /**
+   * Get the table range as RangeAddress
+   */ get rangeAddress() {
+        return {
+            ...this._range
+        };
+    }
+    /**
+   * Get column names
+   */ get columns() {
+        return this._columns.map((c)=>c.name);
+    }
+    /**
+   * Check if table has a total row
+   */ get hasTotalRow() {
+        return this._totalRow;
+    }
+    /**
+   * Check if table has a header row
+   */ get hasHeaderRow() {
+        return this._headerRow;
+    }
+    /**
+   * Check if table has auto-filter enabled
+   */ get hasAutoFilter() {
+        return this._autoFilter;
+    }
+    /**
+   * Get the current style configuration
+   */ get style() {
+        return {
+            ...this._style
+        };
+    }
+    /**
+   * Check if the table has been modified
+   */ get dirty() {
+        return this._dirty;
+    }
+    /**
+   * Set a total function for a column
+   * @param columnName - Name of the column (header text)
+   * @param fn - Aggregation function to use
+   * @returns this for method chaining
+   */ setTotalFunction(columnName, fn) {
+        if (!this._totalRow) {
+            throw new Error('Cannot set total function: table does not have a total row enabled');
+        }
+        const column = this._columns.find((c)=>c.name === columnName);
+        if (!column) {
+            throw new Error(`Column not found: ${columnName}`);
+        }
+        column.totalFunction = fn;
+        this._dirty = true;
+        // Write the formula to the total row cell
+        this._writeTotalRowFormula(column);
+        return this;
+    }
+    /**
+   * Get total function for a column if set
+   */ getTotalFunction(columnName) {
+        const column = this._columns.find((c)=>c.name === columnName);
+        return column?.totalFunction;
+    }
+    /**
+   * Enable or disable auto-filter
+   * @param enabled - Whether auto-filter should be enabled
+   * @returns this for method chaining
+   */ setAutoFilter(enabled) {
+        this._autoFilter = enabled;
+        this._dirty = true;
+        return this;
+    }
+    /**
+   * Update table style configuration
+   * @param style - Style options to apply
+   * @returns this for method chaining
+   */ setStyle(style) {
+        if (style.name !== undefined) this._style.name = style.name;
+        if (style.showRowStripes !== undefined) this._style.showRowStripes = style.showRowStripes;
+        if (style.showColumnStripes !== undefined) this._style.showColumnStripes = style.showColumnStripes;
+        if (style.showFirstColumn !== undefined) this._style.showFirstColumn = style.showFirstColumn;
+        if (style.showLastColumn !== undefined) this._style.showLastColumn = style.showLastColumn;
+        this._dirty = true;
+        return this;
+    }
+    /**
+   * Enable or disable the total row
+   * @param enabled - Whether total row should be shown
+   * @returns this for method chaining
+   */ setTotalRow(enabled) {
+        if (this._totalRow === enabled) return this;
+        this._totalRow = enabled;
+        this._dirty = true;
+        if (enabled) {
+            this._range = {
+                start: {
+                    ...this._baseRange.start
+                },
+                end: {
+                    ...this._baseRange.end
+                }
+            };
+            this._range.end.row++;
+        } else {
+            this._range = {
+                start: {
+                    ...this._baseRange.start
+                },
+                end: {
+                    ...this._baseRange.end
+                }
+            };
+            for (const col of this._columns){
+                col.totalFunction = undefined;
+            }
+        }
+        return this;
+    }
+    /**
+   * Extract column names from the header row of the worksheet
+   */ _extractColumns() {
+        const headerRow = this._range.start.row;
+        const startCol = this._range.start.col;
+        const endCol = this._range.end.col;
+        for(let col = startCol; col <= endCol; col++){
+            const cell = this._headerRow ? this._worksheet.getCellIfExists(headerRow, col) : undefined;
+            const value = cell?.value;
+            const name = value != null ? String(value) : `Column${col - startCol + 1}`;
+            this._columns.push({
+                id: col - startCol + 1,
+                name,
+                colIndex: col
+            });
+        }
+    }
+    /**
+   * Write the SUBTOTAL formula to a total row cell
+   */ _writeTotalRowFormula(column) {
+        if (!this._totalRow || !column.totalFunction || column.totalFunction === 'none') {
+            return;
+        }
+        const totalRowIndex = this._range.end.row;
+        const cell = this._worksheet.cell(totalRowIndex, column.colIndex);
+        // Generate SUBTOTAL formula with structured reference
+        const funcNum = TOTAL_FUNCTION_NUMBERS[column.totalFunction];
+        // Use structured reference: SUBTOTAL(109,[ColumnName])
+        const formula = `SUBTOTAL(${funcNum},[${column.name}])`;
+        cell.formula = formula;
+    }
+    /**
+   * Get the auto-filter range (excludes total row if present)
+   */ _getAutoFilterRange() {
+        const start = toAddress(this._range.start.row, this._range.start.col);
+        // Auto-filter excludes the total row
+        let endRow = this._range.end.row;
+        if (this._totalRow) {
+            endRow--;
+        }
+        const end = toAddress(endRow, this._range.end.col);
+        return `${start}:${end}`;
+    }
+    /**
+   * Generate the table definition XML
+   */ toXml() {
+        const children = [];
+        // Auto-filter element
+        if (this._autoFilter) {
+            const autoFilterRef = this._getAutoFilterRange();
+            children.push(createElement('autoFilter', {
+                ref: autoFilterRef
+            }, []));
+        }
+        // Table columns
+        const columnNodes = this._columns.map((col)=>{
+            const attrs = {
+                id: String(col.id),
+                name: col.name
+            };
+            // Add total function if specified
+            if (this._totalRow && col.totalFunction && col.totalFunction !== 'none') {
+                attrs.totalsRowFunction = TOTAL_FUNCTION_NAMES[col.totalFunction];
+            }
+            return createElement('tableColumn', attrs, []);
+        });
+        children.push(createElement('tableColumns', {
+            count: String(columnNodes.length)
+        }, columnNodes));
+        // Table style info
+        const styleAttrs = {
+            name: this._style.name || 'TableStyleMedium2',
+            showFirstColumn: this._style.showFirstColumn ? '1' : '0',
+            showLastColumn: this._style.showLastColumn ? '1' : '0',
+            showRowStripes: this._style.showRowStripes !== false ? '1' : '0',
+            showColumnStripes: this._style.showColumnStripes ? '1' : '0'
+        };
+        children.push(createElement('tableStyleInfo', styleAttrs, []));
+        // Build table attributes
+        const tableRef = toRange(this._range);
+        const tableAttrs = {
+            xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            id: String(this._id),
+            name: this._name,
+            displayName: this._displayName,
+            ref: tableRef
+        };
+        if (!this._headerRow) {
+            tableAttrs.headerRowCount = '0';
+        }
+        if (this._totalRow) {
+            tableAttrs.totalsRowCount = '1';
+        } else {
+            tableAttrs.totalsRowShown = '0';
+        }
+        // Build complete table node
+        const tableNode = createElement('table', tableAttrs, children);
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
+            tableNode
+        ])}`;
+    }
+}
+
 /**
  * Represents a worksheet in a workbook
  */ class Worksheet {
@@ -611,6 +940,17 @@ const builder = new XMLBuilder(builderOptions);
         this._dirty = false;
         this._mergedCells = new Set();
         this._sheetData = [];
+        this._columnWidths = new Map();
+        this._rowHeights = new Map();
+        this._frozenPane = null;
+        this._dataBoundsCache = null;
+        this._boundsDirty = true;
+        this._tables = [];
+        this._preserveXml = false;
+        this._tableRelIds = null;
+        this._sheetViewsDirty = false;
+        this._colsDirty = false;
+        this._tablePartsDirty = false;
         this._workbook = workbook;
         this._name = name;
     }
@@ -634,15 +974,53 @@ const builder = new XMLBuilder(builderOptions);
    * Parse worksheet XML content
    */ parse(xml) {
         this._xmlNodes = parseXml(xml);
+        this._preserveXml = true;
         const worksheet = findElement(this._xmlNodes, 'worksheet');
         if (!worksheet) return;
         const worksheetChildren = getChildren(worksheet, 'worksheet');
+        // Parse sheet views (freeze panes)
+        const sheetViews = findElement(worksheetChildren, 'sheetViews');
+        if (sheetViews) {
+            const viewChildren = getChildren(sheetViews, 'sheetViews');
+            const sheetView = findElement(viewChildren, 'sheetView');
+            if (sheetView) {
+                const sheetViewChildren = getChildren(sheetView, 'sheetView');
+                const pane = findElement(sheetViewChildren, 'pane');
+                if (pane && getAttr(pane, 'state') === 'frozen') {
+                    const xSplit = parseInt(getAttr(pane, 'xSplit') || '0', 10);
+                    const ySplit = parseInt(getAttr(pane, 'ySplit') || '0', 10);
+                    if (xSplit > 0 || ySplit > 0) {
+                        this._frozenPane = {
+                            row: ySplit,
+                            col: xSplit
+                        };
+                    }
+                }
+            }
+        }
         // Parse sheet data (cells)
         const sheetData = findElement(worksheetChildren, 'sheetData');
         if (sheetData) {
             this._sheetData = getChildren(sheetData, 'sheetData');
             this._parseSheetData(this._sheetData);
         }
+        // Parse column widths
+        const cols = findElement(worksheetChildren, 'cols');
+        if (cols) {
+            const colChildren = getChildren(cols, 'cols');
+            for (const col of colChildren){
+                if (!('col' in col)) continue;
+                const min = parseInt(getAttr(col, 'min') || '0', 10);
+                const max = parseInt(getAttr(col, 'max') || '0', 10);
+                const width = parseFloat(getAttr(col, 'width') || '0');
+                if (!Number.isFinite(width) || width <= 0) continue;
+                if (min > 0 && max > 0) {
+                    for(let idx = min; idx <= max; idx++){
+                        this._columnWidths.set(idx - 1, width);
+                    }
+                }
+            }
+        }
         // Parse merged cells
         const mergeCells = findElement(worksheetChildren, 'mergeCells');
         if (mergeCells) {
@@ -662,6 +1040,11 @@ const builder = new XMLBuilder(builderOptions);
    */ _parseSheetData(rows) {
         for (const rowNode of rows){
             if (!('row' in rowNode)) continue;
+            const rowIndex = parseInt(getAttr(rowNode, 'r') || '0', 10) - 1;
+            const rowHeight = parseFloat(getAttr(rowNode, 'ht') || '0');
+            if (rowIndex >= 0 && Number.isFinite(rowHeight) && rowHeight > 0) {
+                this._rowHeights.set(rowIndex, rowHeight);
+            }
             const rowChildren = getChildren(rowNode, 'row');
             for (const cellNode of rowChildren){
                 if (!('c' in cellNode)) continue;
@@ -673,6 +1056,7 @@ const builder = new XMLBuilder(builderOptions);
                 this._cells.set(ref, cell);
             }
         }
+        this._boundsDirty = true;
     }
     /**
    * Parse a cell XML node to CellData
@@ -759,9 +1143,17 @@ const builder = new XMLBuilder(builderOptions);
         if (!cell) {
             cell = new Cell(this, row, c);
             this._cells.set(address, cell);
+            this._boundsDirty = true;
         }
         return cell;
     }
+    /**
+   * Get an existing cell without creating it.
+   */ getCellIfExists(rowOrAddress, col) {
+        const { row, col: c } = parseCellRef(rowOrAddress, col);
+        const address = toAddress(row, c);
+        return this._cells.get(address);
+    }
     range(startRowOrRange, startCol, endRow, endCol) {
         let rangeAddr;
         if (typeof startRowOrRange === 'string') {
@@ -821,6 +1213,145 @@ const builder = new XMLBuilder(builderOptions);
         return this._cells;
     }
     /**
+   * Set a column width (0-based index or column letter)
+   */ setColumnWidth(col, width) {
+        if (!Number.isFinite(width) || width <= 0) {
+            throw new Error('Column width must be a positive number');
+        }
+        const colIndex = typeof col === 'number' ? col : letterToCol(col);
+        if (colIndex < 0) {
+            throw new Error(`Invalid column: ${col}`);
+        }
+        this._columnWidths.set(colIndex, width);
+        this._colsDirty = true;
+        this._dirty = true;
+    }
+    /**
+   * Get a column width if set
+   */ getColumnWidth(col) {
+        const colIndex = typeof col === 'number' ? col : letterToCol(col);
+        return this._columnWidths.get(colIndex);
+    }
+    /**
+   * Set a row height (0-based index)
+   */ setRowHeight(row, height) {
+        if (!Number.isFinite(height) || height <= 0) {
+            throw new Error('Row height must be a positive number');
+        }
+        if (row < 0) {
+            throw new Error('Row index must be >= 0');
+        }
+        this._rowHeights.set(row, height);
+        this._colsDirty = true;
+        this._dirty = true;
+    }
+    /**
+   * Get a row height if set
+   */ getRowHeight(row) {
+        return this._rowHeights.get(row);
+    }
+    /**
+   * Freeze panes at a given row/column split (counts from top-left)
+   */ freezePane(rowSplit, colSplit) {
+        if (rowSplit < 0 || colSplit < 0) {
+            throw new Error('Freeze pane splits must be >= 0');
+        }
+        if (rowSplit === 0 && colSplit === 0) {
+            this._frozenPane = null;
+        } else {
+            this._frozenPane = {
+                row: rowSplit,
+                col: colSplit
+            };
+        }
+        this._sheetViewsDirty = true;
+        this._dirty = true;
+    }
+    /**
+   * Get current frozen pane configuration
+   */ getFrozenPane() {
+        return this._frozenPane ? {
+            ...this._frozenPane
+        } : null;
+    }
+    /**
+   * Get all tables in the worksheet
+   */ get tables() {
+        return [
+            ...this._tables
+        ];
+    }
+    /**
+   * Get column width entries
+   * @internal
+   */ getColumnWidths() {
+        return new Map(this._columnWidths);
+    }
+    /**
+   * Get row height entries
+   * @internal
+   */ getRowHeights() {
+        return new Map(this._rowHeights);
+    }
+    /**
+   * Set table relationship IDs for tableParts generation.
+   * @internal
+   */ setTableRelIds(ids) {
+        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');
+   * ```
+   */ createTable(config) {
+        // Validate table name is unique within the workbook
+        for (const sheet of this._workbook.sheetNames){
+            const ws = this._workbook.sheet(sheet);
+            for (const table of ws._tables){
+                if (table.name === config.name) {
+                    throw new Error(`Table name already exists: ${config.name}`);
+                }
+            }
+        }
+        // Validate table name format (Excel rules: no spaces at start/end, alphanumeric + underscore)
+        if (!config.name || !/^[A-Za-z_\\][A-Za-z0-9_.\\]*$/.test(config.name)) {
+            throw new Error(`Invalid table name: ${config.name}. Names must start with a letter or underscore and contain only alphanumeric characters, underscores, or periods.`);
+        }
+        // Create the table with a unique ID from the workbook
+        const tableId = this._workbook.getNextTableId();
+        const table = new Table(this, config, tableId);
+        this._tables.push(table);
+        this._tablePartsDirty = true;
+        this._dirty = true;
+        return table;
+    }
+    /**
    * Convert sheet data to an array of JSON objects.
    *
    * @param config - Configuration options
@@ -838,7 +1369,7 @@ const builder = new XMLBuilder(builderOptions);
    * const data = sheet.toJson({ startRow: 2, startCol: 1 });
    * ```
    */ toJson(config = {}) {
-        const { fields, startRow = 0, startCol = 0, endRow, endCol, stopOnEmptyRow = true } = config;
+        const { fields, startRow = 0, startCol = 0, endRow, endCol, stopOnEmptyRow = true, dateHandling = this._workbook.dateHandling } = config;
         // Get the bounds of data in the sheet
         const bounds = this._getDataBounds();
         if (!bounds) {
@@ -871,7 +1402,10 @@ const builder = new XMLBuilder(builderOptions);
             for(let colOffset = 0; colOffset < fieldNames.length; colOffset++){
                 const col = startCol + colOffset;
                 const cell = this._cells.get(toAddress(row, col));
-                const value = cell?.value ?? null;
+                let value = cell?.value ?? null;
+                if (value instanceof Date) {
+                    value = this._serializeDate(value, dateHandling, cell);
+                }
                 if (value !== null) {
                     hasData = true;
                 }
@@ -888,10 +1422,24 @@ const builder = new XMLBuilder(builderOptions);
         }
         return result;
     }
+    _serializeDate(value, dateHandling, cell) {
+        if (dateHandling === 'excelSerial') {
+            return cell?._jsDateToExcel(value) ?? value;
+        }
+        if (dateHandling === 'isoString') {
+            return value.toISOString();
+        }
+        return value;
+    }
     /**
    * Get the bounds of data in the sheet (min/max row and column with data)
    */ _getDataBounds() {
+        if (!this._boundsDirty && this._dataBoundsCache) {
+            return this._dataBoundsCache;
+        }
         if (this._cells.size === 0) {
+            this._dataBoundsCache = null;
+            this._boundsDirty = false;
             return null;
         }
         let minRow = Infinity;
@@ -907,47 +1455,78 @@ const builder = new XMLBuilder(builderOptions);
             }
         }
         if (minRow === Infinity) {
+            this._dataBoundsCache = null;
+            this._boundsDirty = false;
             return null;
         }
-        return {
+        this._dataBoundsCache = {
             minRow,
             maxRow,
             minCol,
             maxCol
         };
+        this._boundsDirty = false;
+        return this._dataBoundsCache;
     }
     /**
    * Generate XML for this worksheet
    */ toXml() {
+        const preserved = this._preserveXml && this._xmlNodes ? this._buildPreservedWorksheet() : null;
         // Build sheetData from cells
-        const rowMap = new Map();
-        for (const cell of this._cells.values()){
-            const row = cell.row;
-            if (!rowMap.has(row)) {
-                rowMap.set(row, []);
+        const sheetDataNode = this._buildSheetDataNode();
+        // Build worksheet structure
+        const worksheetChildren = [];
+        // Sheet views (freeze panes)
+        if (this._frozenPane) {
+            const paneAttrs = {
+                state: 'frozen'
+            };
+            const topLeftCell = toAddress(this._frozenPane.row, this._frozenPane.col);
+            paneAttrs.topLeftCell = topLeftCell;
+            if (this._frozenPane.col > 0) {
+                paneAttrs.xSplit = String(this._frozenPane.col);
             }
-            rowMap.get(row).push(cell);
+            if (this._frozenPane.row > 0) {
+                paneAttrs.ySplit = String(this._frozenPane.row);
+            }
+            let activePane = 'bottomRight';
+            if (this._frozenPane.row > 0 && this._frozenPane.col === 0) {
+                activePane = 'bottomLeft';
+            } else if (this._frozenPane.row === 0 && this._frozenPane.col > 0) {
+                activePane = 'topRight';
+            }
+            paneAttrs.activePane = activePane;
+            const paneNode = createElement('pane', paneAttrs, []);
+            const selectionNode = createElement('selection', {
+                pane: activePane,
+                activeCell: topLeftCell,
+                sqref: topLeftCell
+            }, []);
+            const sheetViewNode = createElement('sheetView', {
+                workbookViewId: '0'
+            }, [
+                paneNode,
+                selectionNode
+            ]);
+            worksheetChildren.push(createElement('sheetViews', {}, [
+                sheetViewNode
+            ]));
         }
-        // Sort rows and cells
-        const sortedRows = Array.from(rowMap.entries()).sort((a, b)=>a[0] - b[0]);
-        const rowNodes = [];
-        for (const [rowIdx, cells] of sortedRows){
-            cells.sort((a, b)=>a.col - b.col);
-            const cellNodes = [];
-            for (const cell of cells){
-                const cellNode = this._buildCellNode(cell);
-                cellNodes.push(cellNode);
+        // Column widths
+        if (this._columnWidths.size > 0) {
+            const colNodes = [];
+            const entries = Array.from(this._columnWidths.entries()).sort((a, b)=>a[0] - b[0]);
+            for (const [colIndex, width] of entries){
+                colNodes.push(createElement('col', {
+                    min: String(colIndex + 1),
+                    max: String(colIndex + 1),
+                    width: String(width),
+                    customWidth: '1'
+                }, []));
             }
-            const rowNode = createElement('row', {
-                r: String(rowIdx + 1)
-            }, cellNodes);
-            rowNodes.push(rowNode);
+            worksheetChildren.push(createElement('cols', {}, colNodes));
         }
-        const sheetDataNode = createElement('sheetData', {}, rowNodes);
-        // Build worksheet structure
-        const worksheetChildren = [
-            sheetDataNode
-        ];
+        worksheetChildren.push(sheetDataNode);
         // Add merged cells if any
         if (this._mergedCells.size > 0) {
             const mergeCellNodes = [];
@@ -961,14 +1540,170 @@ const builder = new XMLBuilder(builderOptions);
             }, mergeCellNodes);
             worksheetChildren.push(mergeCellsNode);
         }
+        // Add table parts if any tables exist
+        const tablePartsNode = this._buildTablePartsNode();
+        if (tablePartsNode) {
+            worksheetChildren.push(tablePartsNode);
+        }
         const worksheetNode = createElement('worksheet', {
             xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
             'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships'
         }, worksheetChildren);
+        if (preserved) {
+            return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
+                preserved
+            ])}`;
+        }
         return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
             worksheetNode
         ])}`;
     }
+    _buildSheetDataNode() {
+        const rowMap = new Map();
+        for (const cell of this._cells.values()){
+            const row = cell.row;
+            if (!rowMap.has(row)) {
+                rowMap.set(row, []);
+            }
+            rowMap.get(row).push(cell);
+        }
+        for (const rowIdx of this._rowHeights.keys()){
+            if (!rowMap.has(rowIdx)) {
+                rowMap.set(rowIdx, []);
+            }
+        }
+        const sortedRows = Array.from(rowMap.entries()).sort((a, b)=>a[0] - b[0]);
+        const rowNodes = [];
+        for (const [rowIdx, cells] of sortedRows){
+            cells.sort((a, b)=>a.col - b.col);
+            const cellNodes = [];
+            for (const cell of cells){
+                const cellNode = this._buildCellNode(cell);
+                cellNodes.push(cellNode);
+            }
+            const rowAttrs = {
+                r: String(rowIdx + 1)
+            };
+            const rowHeight = this._rowHeights.get(rowIdx);
+            if (rowHeight !== undefined) {
+                rowAttrs.ht = String(rowHeight);
+                rowAttrs.customHeight = '1';
+            }
+            const rowNode = createElement('row', rowAttrs, cellNodes);
+            rowNodes.push(rowNode);
+        }
+        return createElement('sheetData', {}, rowNodes);
+    }
+    _buildSheetViewsNode() {
+        if (!this._frozenPane) return null;
+        const paneAttrs = {
+            state: 'frozen'
+        };
+        const topLeftCell = toAddress(this._frozenPane.row, this._frozenPane.col);
+        paneAttrs.topLeftCell = topLeftCell;
+        if (this._frozenPane.col > 0) {
+            paneAttrs.xSplit = String(this._frozenPane.col);
+        }
+        if (this._frozenPane.row > 0) {
+            paneAttrs.ySplit = String(this._frozenPane.row);
+        }
+        let activePane = 'bottomRight';
+        if (this._frozenPane.row > 0 && this._frozenPane.col === 0) {
+            activePane = 'bottomLeft';
+        } else if (this._frozenPane.row === 0 && this._frozenPane.col > 0) {
+            activePane = 'topRight';
+        }
+        paneAttrs.activePane = activePane;
+        const paneNode = createElement('pane', paneAttrs, []);
+        const selectionNode = createElement('selection', {
+            pane: activePane,
+            activeCell: topLeftCell,
+            sqref: topLeftCell
+        }, []);
+        const sheetViewNode = createElement('sheetView', {
+            workbookViewId: '0'
+        }, [
+            paneNode,
+            selectionNode
+        ]);
+        return createElement('sheetViews', {}, [
+            sheetViewNode
+        ]);
+    }
+    _buildColsNode() {
+        if (this._columnWidths.size === 0) return null;
+        const colNodes = [];
+        const entries = Array.from(this._columnWidths.entries()).sort((a, b)=>a[0] - b[0]);
+        for (const [colIndex, width] of entries){
+            colNodes.push(createElement('col', {
+                min: String(colIndex + 1),
+                max: String(colIndex + 1),
+                width: String(width),
+                customWidth: '1'
+            }, []));
+        }
+        return createElement('cols', {}, colNodes);
+    }
+    _buildMergeCellsNode() {
+        if (this._mergedCells.size === 0) return null;
+        const mergeCellNodes = [];
+        for (const ref of this._mergedCells){
+            mergeCellNodes.push(createElement('mergeCell', {
+                ref
+            }, []));
+        }
+        return createElement('mergeCells', {
+            count: String(this._mergedCells.size)
+        }, mergeCellNodes);
+    }
+    _buildTablePartsNode() {
+        if (this._tables.length === 0) return null;
+        const tablePartNodes = [];
+        for(let i = 0; i < this._tables.length; i++){
+            const relId = this._tableRelIds && this._tableRelIds.length === this._tables.length ? this._tableRelIds[i] : `rId${i + 1}`;
+            tablePartNodes.push(createElement('tablePart', {
+                'r:id': relId
+            }, []));
+        }
+        return createElement('tableParts', {
+            count: String(this._tables.length)
+        }, tablePartNodes);
+    }
+    _buildPreservedWorksheet() {
+        if (!this._xmlNodes) return null;
+        const worksheet = findElement(this._xmlNodes, 'worksheet');
+        if (!worksheet) return null;
+        const children = getChildren(worksheet, 'worksheet');
+        const upsertChild = (tag, node)=>{
+            const existingIndex = children.findIndex((child)=>tag in child);
+            if (node) {
+                if (existingIndex >= 0) {
+                    children[existingIndex] = node;
+                } else {
+                    children.push(node);
+                }
+            } else if (existingIndex >= 0) {
+                children.splice(existingIndex, 1);
+            }
+        };
+        if (this._sheetViewsDirty) {
+            const sheetViewsNode = this._buildSheetViewsNode();
+            upsertChild('sheetViews', sheetViewsNode);
+        }
+        if (this._colsDirty) {
+            const colsNode = this._buildColsNode();
+            upsertChild('cols', colsNode);
+        }
+        const sheetDataNode = this._buildSheetDataNode();
+        upsertChild('sheetData', sheetDataNode);
+        const mergeCellsNode = this._buildMergeCellsNode();
+        upsertChild('mergeCells', mergeCellsNode);
+        if (this._tablePartsDirty) {
+            const tablePartsNode = this._buildTablePartsNode();
+            upsertChild('tableParts', tablePartsNode);
+        }
+        return worksheet;
+    }
     /**
    * Build a cell XML node from a Cell object
    */ _buildCellNode(cell) {
@@ -1013,15 +1748,28 @@ const builder = new XMLBuilder(builderOptions);
         const parsed = parseXml(xml);
         const sst = findElement(parsed, 'sst');
         if (!sst) return ss;
+        const countAttr = getAttr(sst, 'count');
+        if (countAttr) {
+            const total = parseInt(countAttr, 10);
+            if (Number.isFinite(total) && total >= 0) {
+                ss._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.strings.push(text);
-                ss.stringToIndex.set(text, ss.strings.length - 1);
+                ss.entries.push({
+                    text,
+                    node: child
+                });
+                ss.stringToIndex.set(text, ss.entries.length - 1);
             }
         }
+        if (ss._totalCount === 0 && ss.entries.length > 0) {
+            ss._totalCount = ss.entries.length;
+        }
         return ss;
     }
     /**
@@ -1058,7 +1806,7 @@ const builder = new XMLBuilder(builderOptions);
     /**
    * Get a string by index
    */ getString(index) {
-        return this.strings[index];
+        return this.entries[index]?.text;
     }
     /**
    * Add a string and return its index
@@ -1066,11 +1814,25 @@ const builder = new XMLBuilder(builderOptions);
    */ addString(str) {
         const existing = this.stringToIndex.get(str);
         if (existing !== undefined) {
+            this._totalCount++;
+            this._dirty = true;
             return existing;
         }
-        const index = this.strings.length;
-        this.strings.push(str);
+        const index = this.entries.length;
+        const tElement = createElement('t', str.startsWith(' ') || str.endsWith(' ') ? {
+            'xml:space': 'preserve'
+        } : {}, [
+            createText(str)
+        ]);
+        const siElement = createElement('si', {}, [
+            tElement
+        ]);
+        this.entries.push({
+            text: str,
+            node: siElement
+        });
         this.stringToIndex.set(str, index);
+        this._totalCount++;
         this._dirty = true;
         return index;
     }
@@ -1082,36 +1844,48 @@ const builder = new XMLBuilder(builderOptions);
     /**
    * Get the count of strings
    */ get count() {
-        return this.strings.length;
+        return this.entries.length;
+    }
+    /**
+   * Get total usage count of shared strings
+   */ get totalCount() {
+        return Math.max(this._totalCount, this.entries.length);
     }
     /**
    * Generate XML for the shared strings table
    */ toXml() {
         const siElements = [];
-        for (const str of this.strings){
-            const tElement = createElement('t', str.startsWith(' ') || str.endsWith(' ') ? {
-                'xml:space': 'preserve'
-            } : {}, [
-                createText(str)
-            ]);
-            const siElement = createElement('si', {}, [
-                tElement
-            ]);
-            siElements.push(siElement);
+        for (const entry of this.entries){
+            if (entry.node) {
+                siElements.push(entry.node);
+            } else {
+                const str = entry.text;
+                const tElement = createElement('t', str.startsWith(' ') || str.endsWith(' ') ? {
+                    'xml:space': 'preserve'
+                } : {}, [
+                    createText(str)
+                ]);
+                const siElement = createElement('si', {}, [
+                    tElement
+                ]);
+                siElements.push(siElement);
+            }
         }
+        const totalCount = Math.max(this._totalCount, this.entries.length);
         const sst = createElement('sst', {
             xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
-            count: String(this.strings.length),
-            uniqueCount: String(this.strings.length)
+            count: String(totalCount),
+            uniqueCount: String(this.entries.length)
         }, siElements);
         return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
             sst
         ])}`;
     }
     constructor(){
-        this.strings = [];
+        this.entries = [];
         this.stringToIndex = new Map();
         this._dirty = false;
+        this._totalCount = 0;
     }
 }
 
@@ -1257,6 +2031,50 @@ const builder = new XMLBuilder(builderOptions);
  * Manages the styles (xl/styles.xml)
  */ class Styles {
     /**
+   * Generate a deterministic cache key for a style object.
+   * More efficient than JSON.stringify as it avoids the overhead of
+   * full JSON serialization and produces a consistent key regardless
+   * of property order.
+   */ _getStyleKey(style) {
+        // Use a delimiter that won't appear in values
+        const SEP = '\x00';
+        // Build key from all style properties in a fixed order
+        const parts = [
+            style.bold ? '1' : '0',
+            style.italic ? '1' : '0',
+            style.underline === true ? '1' : style.underline === 'single' ? 's' : style.underline === 'double' ? 'd' : '0',
+            style.strike ? '1' : '0',
+            style.fontSize?.toString() ?? '',
+            style.fontName ?? '',
+            style.fontColor ?? '',
+            style.fontColorTheme?.toString() ?? '',
+            style.fontColorTint?.toString() ?? '',
+            style.fontColorIndexed?.toString() ?? '',
+            style.fill ?? '',
+            style.fillTheme?.toString() ?? '',
+            style.fillTint?.toString() ?? '',
+            style.fillIndexed?.toString() ?? '',
+            style.fillBgColor ?? '',
+            style.fillBgTheme?.toString() ?? '',
+            style.fillBgTint?.toString() ?? '',
+            style.fillBgIndexed?.toString() ?? '',
+            style.numberFormat ?? ''
+        ];
+        // Border properties
+        if (style.border) {
+            parts.push(style.border.top ?? '', style.border.bottom ?? '', style.border.left ?? '', style.border.right ?? '');
+        } else {
+            parts.push('', '', '', '');
+        }
+        // Alignment properties
+        if (style.alignment) {
+            parts.push(style.alignment.horizontal ?? '', style.alignment.vertical ?? '', style.alignment.wrapText ? '1' : '0', style.alignment.textRotation?.toString() ?? '');
+        } else {
+            parts.push('', '', '0', '');
+        }
+        return parts.join(SEP);
+    }
+    /**
    * Parse styles from XML content
    */ static parse(xml) {
         const styles = new Styles();
@@ -1361,7 +2179,18 @@ const builder = new XMLBuilder(builderOptions);
             if ('sz' in child) font.size = parseFloat(getAttr(child, 'val') || '11');
             if ('name' in child) font.name = getAttr(child, 'val');
             if ('color' in child) {
-                font.color = getAttr(child, 'rgb') || getAttr(child, 'theme');
+                const color = {};
+                const rgb = getAttr(child, 'rgb');
+                const theme = getAttr(child, 'theme');
+                const tint = getAttr(child, 'tint');
+                const indexed = getAttr(child, 'indexed');
+                if (rgb) color.rgb = rgb;
+                if (theme) color.theme = theme;
+                if (tint) color.tint = tint;
+                if (indexed) color.indexed = indexed;
+                if (color.rgb || color.theme || color.tint || color.indexed) {
+                    font.color = color;
+                }
             }
         }
         return font;
@@ -1378,10 +2207,32 @@ const builder = new XMLBuilder(builderOptions);
                 const pfChildren = getChildren(child, 'patternFill');
                 for (const pfChild of pfChildren){
                     if ('fgColor' in pfChild) {
-                        fill.fgColor = getAttr(pfChild, 'rgb') || getAttr(pfChild, 'theme');
+                        const color = {};
+                        const rgb = getAttr(pfChild, 'rgb');
+                        const theme = getAttr(pfChild, 'theme');
+                        const tint = getAttr(pfChild, 'tint');
+                        const indexed = getAttr(pfChild, 'indexed');
+                        if (rgb) color.rgb = rgb;
+                        if (theme) color.theme = theme;
+                        if (tint) color.tint = tint;
+                        if (indexed) color.indexed = indexed;
+                        if (color.rgb || color.theme || color.tint || color.indexed) {
+                            fill.fgColor = color;
+                        }
                     }
                     if ('bgColor' in pfChild) {
-                        fill.bgColor = getAttr(pfChild, 'rgb') || getAttr(pfChild, 'theme');
+                        const color = {};
+                        const rgb = getAttr(pfChild, 'rgb');
+                        const theme = getAttr(pfChild, 'theme');
+                        const tint = getAttr(pfChild, 'tint');
+                        const indexed = getAttr(pfChild, 'indexed');
+                        if (rgb) color.rgb = rgb;
+                        if (theme) color.theme = theme;
+                        if (tint) color.tint = tint;
+                        if (indexed) color.indexed = indexed;
+                        if (color.rgb || color.theme || color.tint || color.indexed) {
+                            fill.bgColor = color;
+                        }
                     }
                 }
             }
@@ -1423,6 +2274,10 @@ const builder = new XMLBuilder(builderOptions);
     /**
    * Get a style by index
    */ getStyle(index) {
+        const cached = this._styleObjectCache.get(index);
+        if (cached) return {
+            ...cached
+        };
         const xf = this._cellXfs[index];
         if (!xf) return {};
         const font = this._fonts[xf.fontId];
@@ -1438,10 +2293,22 @@ const builder = new XMLBuilder(builderOptions);
             if (font.strike) style.strike = true;
             if (font.size) style.fontSize = font.size;
             if (font.name) style.fontName = font.name;
-            if (font.color) style.fontColor = font.color;
+            if (font.color?.rgb) style.fontColor = font.color.rgb;
+            if (font.color?.theme) style.fontColorTheme = Number(font.color.theme);
+            if (font.color?.tint) style.fontColorTint = Number(font.color.tint);
+            if (font.color?.indexed) style.fontColorIndexed = Number(font.color.indexed);
         }
         if (fill && fill.fgColor) {
-            style.fill = fill.fgColor;
+            if (fill.fgColor.rgb) style.fill = fill.fgColor.rgb;
+            if (fill.fgColor.theme) style.fillTheme = Number(fill.fgColor.theme);
+            if (fill.fgColor.tint) style.fillTint = Number(fill.fgColor.tint);
+            if (fill.fgColor.indexed) style.fillIndexed = Number(fill.fgColor.indexed);
+        }
+        if (fill && fill.bgColor) {
+            if (fill.bgColor.rgb) style.fillBgColor = fill.bgColor.rgb;
+            if (fill.bgColor.theme) style.fillBgTheme = Number(fill.bgColor.theme);
+            if (fill.bgColor.tint) style.fillBgTint = Number(fill.bgColor.tint);
+            if (fill.bgColor.indexed) style.fillBgIndexed = Number(fill.bgColor.indexed);
         }
         if (border) {
             if (border.top || border.bottom || border.left || border.right) {
@@ -1464,13 +2331,16 @@ const builder = new XMLBuilder(builderOptions);
                 textRotation: xf.alignment.textRotation
             };
         }
+        this._styleObjectCache.set(index, {
+            ...style
+        });
         return style;
     }
     /**
    * Create a style and return its index
    * Uses caching to deduplicate identical styles
    */ createStyle(style) {
-        const key = JSON.stringify(style);
+        const key = this._getStyleKey(style);
         const cached = this._styleCache.get(key);
         if (cached !== undefined) {
             return cached;
@@ -1502,9 +2372,22 @@ const builder = new XMLBuilder(builderOptions);
         const index = this._cellXfs.length;
         this._cellXfs.push(xf);
         this._styleCache.set(key, index);
+        this._styleObjectCache.set(index, {
+            ...style
+        });
         return index;
     }
+    /**
+   * Clone an existing style by index, optionally overriding fields.
+   */ cloneStyle(index, overrides = {}) {
+        const baseStyle = this.getStyle(index);
+        return this.createStyle({
+            ...baseStyle,
+            ...overrides
+        });
+    }
     _findOrCreateFont(style) {
+        const color = this._toStyleColor(style.fontColor, style.fontColorTheme, style.fontColorTint, style.fontColorIndexed);
         const font = {
             bold: style.bold || false,
             italic: style.italic || false,
@@ -1512,12 +2395,12 @@ const builder = new XMLBuilder(builderOptions);
             strike: style.strike || false,
             size: style.fontSize,
             name: style.fontName,
-            color: style.fontColor
+            color
         };
         // Try to find existing font
         for(let i = 0; i < this._fonts.length; i++){
             const f = this._fonts[i];
-            if (f.bold === font.bold && f.italic === font.italic && f.underline === font.underline && f.strike === font.strike && f.size === font.size && f.name === font.name && f.color === font.color) {
+            if (f.bold === font.bold && f.italic === font.italic && f.underline === font.underline && f.strike === font.strike && f.size === font.size && f.name === font.name && this._colorsEqual(f.color, font.color)) {
                 return i;
             }
         }
@@ -1526,18 +2409,21 @@ const builder = new XMLBuilder(builderOptions);
         return this._fonts.length - 1;
     }
     _findOrCreateFill(style) {
-        if (!style.fill) return 0;
+        const fgColor = this._toStyleColor(style.fill, style.fillTheme, style.fillTint, style.fillIndexed);
+        const bgColor = this._toStyleColor(style.fillBgColor, style.fillBgTheme, style.fillBgTint, style.fillBgIndexed);
+        if (!fgColor && !bgColor) return 0;
         // Try to find existing fill
         for(let i = 0; i < this._fills.length; i++){
             const f = this._fills[i];
-            if (f.fgColor === style.fill) {
+            if (this._colorsEqual(f.fgColor, fgColor) && this._colorsEqual(f.bgColor, bgColor)) {
                 return i;
             }
         }
         // Create new fill
         this._fills.push({
             type: 'solid',
-            fgColor: style.fill
+            fgColor: fgColor || undefined,
+            bgColor: bgColor || undefined
         });
         return this._fills.length - 1;
     }
@@ -1663,9 +2549,16 @@ const builder = new XMLBuilder(builderOptions);
         if (font.size) children.push(createElement('sz', {
             val: String(font.size)
         }, []));
-        if (font.color) children.push(createElement('color', {
-            rgb: normalizeColor(font.color)
-        }, []));
+        if (font.color) {
+            const attrs = {};
+            if (font.color.rgb) attrs.rgb = normalizeColor(font.color.rgb);
+            if (font.color.theme) attrs.theme = font.color.theme;
+            if (font.color.tint) attrs.tint = font.color.tint;
+            if (font.color.indexed) attrs.indexed = font.color.indexed;
+            if (Object.keys(attrs).length > 0) {
+                children.push(createElement('color', attrs, []));
+            }
+        }
         if (font.name) children.push(createElement('name', {
             val: font.name
         }, []));
@@ -1674,22 +2567,30 @@ const builder = new XMLBuilder(builderOptions);
     _buildFillNode(fill) {
         const patternChildren = [];
         if (fill.fgColor) {
-            const rgb = normalizeColor(fill.fgColor);
-            patternChildren.push(createElement('fgColor', {
-                rgb
-            }, []));
+            const attrs = {};
+            if (fill.fgColor.rgb) attrs.rgb = normalizeColor(fill.fgColor.rgb);
+            if (fill.fgColor.theme) attrs.theme = fill.fgColor.theme;
+            if (fill.fgColor.tint) attrs.tint = fill.fgColor.tint;
+            if (fill.fgColor.indexed) attrs.indexed = fill.fgColor.indexed;
+            if (Object.keys(attrs).length > 0) {
+                patternChildren.push(createElement('fgColor', attrs, []));
+            }
             // For solid fills, bgColor is required (indexed 64 = system background)
-            if (fill.type === 'solid') {
+            if (fill.type === 'solid' && !fill.bgColor) {
                 patternChildren.push(createElement('bgColor', {
                     indexed: '64'
                 }, []));
             }
         }
-        if (fill.bgColor && fill.type !== 'solid') {
-            const rgb = normalizeColor(fill.bgColor);
-            patternChildren.push(createElement('bgColor', {
-                rgb
-            }, []));
+        if (fill.bgColor) {
+            const attrs = {};
+            if (fill.bgColor.rgb) attrs.rgb = normalizeColor(fill.bgColor.rgb);
+            if (fill.bgColor.theme) attrs.theme = fill.bgColor.theme;
+            if (fill.bgColor.tint) attrs.tint = fill.bgColor.tint;
+            if (fill.bgColor.indexed) attrs.indexed = fill.bgColor.indexed;
+            if (Object.keys(attrs).length > 0) {
+                patternChildren.push(createElement('bgColor', attrs, []));
+            }
         }
         const patternFill = createElement('patternFill', {
             patternType: fill.type || 'none'
@@ -1698,6 +2599,24 @@ const builder = new XMLBuilder(builderOptions);
             patternFill
         ]);
     }
+    _toStyleColor(rgb, theme, tint, indexed) {
+        if (rgb) {
+            return {
+                rgb
+            };
+        }
+        const color = {};
+        if (theme !== undefined) color.theme = String(theme);
+        if (tint !== undefined) color.tint = String(tint);
+        if (indexed !== undefined) color.indexed = String(indexed);
+        if (color.theme || color.tint || color.indexed) return color;
+        return undefined;
+    }
+    _colorsEqual(a, b) {
+        if (!a && !b) return true;
+        if (!a || !b) return false;
+        return a.rgb === b.rgb && a.theme === b.theme && a.tint === b.tint && a.indexed === b.indexed;
+    }
     _buildBorderNode(border) {
         const children = [];
         if (border.left) children.push(createElement('left', {
@@ -1753,17 +2672,19 @@ const builder = new XMLBuilder(builderOptions);
         this._dirty = false;
         // Cache for style deduplication
         this._styleCache = new Map();
+        this._styleObjectCache = new Map();
     }
 }
 
 /**
  * Represents an Excel pivot table with a fluent API for configuration.
  */ class PivotTable {
-    constructor(name, cache, targetSheet, targetCell, targetRow, targetCol, pivotTableIndex){
+    constructor(name, cache, targetSheet, targetCell, targetRow, targetCol, pivotTableIndex, cacheFileIndex){
         this._rowFields = [];
         this._columnFields = [];
         this._valueFields = [];
         this._filterFields = [];
+        this._fieldAssignments = new Map();
         this._styles = null;
         this._name = name;
         this._cache = cache;
@@ -1772,6 +2693,7 @@ const builder = new XMLBuilder(builderOptions);
         this._targetRow = targetRow;
         this._targetCol = targetCol;
         this._pivotTableIndex = pivotTableIndex;
+        this._cacheFileIndex = cacheFileIndex;
     }
     /**
    * Get the pivot table name
@@ -1799,6 +2721,12 @@ const builder = new XMLBuilder(builderOptions);
         return this._pivotTableIndex;
     }
     /**
+   * Get the pivot cache file index used for rels.
+   * @internal
+   */ get cacheFileIndex() {
+        return this._cacheFileIndex;
+    }
+    /**
    * Set the styles reference for number format resolution
    * @internal
    */ setStyles(styles) {
@@ -1813,11 +2741,13 @@ const builder = new XMLBuilder(builderOptions);
         if (fieldIndex < 0) {
             throw new Error(`Field not found in source data: ${fieldName}`);
         }
-        this._rowFields.push({
+        const assignment = {
             fieldName,
             fieldIndex,
             axis: 'row'
-        });
+        };
+        this._rowFields.push(assignment);
+        this._fieldAssignments.set(fieldIndex, assignment);
         return this;
     }
     /**
@@ -1828,33 +2758,52 @@ const builder = new XMLBuilder(builderOptions);
         if (fieldIndex < 0) {
             throw new Error(`Field not found in source data: ${fieldName}`);
         }
-        this._columnFields.push({
+        const assignment = {
             fieldName,
             fieldIndex,
             axis: 'column'
-        });
+        };
+        this._columnFields.push(assignment);
+        this._fieldAssignments.set(fieldIndex, assignment);
         return this;
     }
-    /**
-   * Add a field to the values area with aggregation
-   * @param fieldName - Name of the source field (column header)
-   * @param aggregation - Aggregation function (sum, count, average, min, max)
-   * @param displayName - Optional display name (defaults to "Sum of FieldName")
-   * @param numberFormat - Optional number format (e.g., '$#,##0.00', '0.00%')
-   */ addValueField(fieldName, aggregation = 'sum', displayName, numberFormat) {
+    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;
+        } 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 = `${aggregation.charAt(0).toUpperCase() + aggregation.slice(1)} of ${fieldName}`;
-        this._valueFields.push({
+        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,
-            displayName: displayName || defaultName,
-            numberFormat
-        });
+            aggregation: agg,
+            displayName: name || defaultName,
+            numFmtId
+        };
+        this._valueFields.push(assignment);
+        this._fieldAssignments.set(fieldIndex, assignment);
         return this;
     }
     /**
@@ -1865,11 +2814,51 @@ const builder = new XMLBuilder(builderOptions);
         if (fieldIndex < 0) {
             throw new Error(`Field not found in source data: ${fieldName}`);
         }
-        this._filterFields.push({
+        const assignment = {
             fieldName,
             fieldIndex,
             axis: 'filter'
-        });
+        };
+        this._filterFields.push(assignment);
+        this._fieldAssignments.set(fieldIndex, assignment);
+        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}`);
+        }
+        const assignment = this._fieldAssignments.get(fieldIndex);
+        if (!assignment) {
+            throw new Error(`Field is not assigned to pivot table: ${fieldName}`);
+        }
+        if (assignment.axis !== 'row' && assignment.axis !== 'column') {
+            throw new Error(`Sort is only supported for row or column fields: ${fieldName}`);
+        }
+        assignment.sortOrder = order;
+        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;
     }
     /**
@@ -1984,9 +2973,9 @@ const builder = new XMLBuilder(builderOptions);
                     baseItem: '0',
                     subtotal: f.aggregation || 'sum'
                 };
-                // Add numFmtId if format specified and styles available
-                if (f.numberFormat && this._styles) {
-                    attrs.numFmtId = String(this._styles.getOrCreateNumFmtId(f.numberFormat));
+                // Add numFmtId if it was resolved during addValueField
+                if (f.numFmtId !== undefined) {
+                    attrs.numFmtId = String(f.numFmtId);
                 }
                 return createElement('dataField', attrs, []);
             });
@@ -1995,7 +2984,7 @@ const builder = new XMLBuilder(builderOptions);
             }, dataFieldNodes));
         }
         // Check if any value field has a number format
-        const hasNumberFormats = this._valueFields.some((f)=>f.numberFormat);
+        const hasNumberFormats = this._valueFields.some((f)=>f.numFmtId !== undefined);
         // Pivot table style
         children.push(createElement('pivotTableStyleInfo', {
             name: 'PivotStyleMedium9',
@@ -2043,22 +3032,19 @@ const builder = new XMLBuilder(builderOptions);
         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 = [];
-                for(let i = 0; i < cacheField.sharedItems.length; i++){
-                    itemNodes.push(createElement('item', {
-                        x: String(i)
-                    }, []));
-                }
-                // Add default subtotal item
-                itemNodes.push(createElement('item', {
-                    t: 'default'
-                }, []));
+                const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
                 children.push(createElement('items', {
                     count: String(itemNodes.length)
                 }, itemNodes));
@@ -2066,17 +3052,13 @@ const builder = new XMLBuilder(builderOptions);
         } 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 = [];
-                for(let i = 0; i < cacheField.sharedItems.length; i++){
-                    itemNodes.push(createElement('item', {
-                        x: String(i)
-                    }, []));
-                }
-                itemNodes.push(createElement('item', {
-                    t: 'default'
-                }, []));
+                const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
                 children.push(createElement('items', {
                     count: String(itemNodes.length)
                 }, itemNodes));
@@ -2086,15 +3068,7 @@ const builder = new XMLBuilder(builderOptions);
             attrs.showAll = '0';
             const cacheField = this._cache.fields[fieldIndex];
             if (cacheField && cacheField.sharedItems.length > 0) {
-                const itemNodes = [];
-                for(let i = 0; i < cacheField.sharedItems.length; i++){
-                    itemNodes.push(createElement('item', {
-                        x: String(i)
-                    }, []));
-                }
-                itemNodes.push(createElement('item', {
-                    t: 'default'
-                }, []));
+                const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
                 children.push(createElement('items', {
                     count: String(itemNodes.length)
                 }, itemNodes));
@@ -2108,6 +3082,35 @@ const builder = new XMLBuilder(builderOptions);
         return createElement('pivotField', attrs, children);
     }
     /**
+   * 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';
+                }
+            }
+            itemNodes.push(createElement('item', itemAttrs, []));
+        }
+        // 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 = [];
@@ -2252,7 +3255,7 @@ const builder = new XMLBuilder(builderOptions);
  * 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){
+    constructor(cacheId, sourceSheet, sourceRange, fileIndex){
         this._fields = [];
         this._records = [];
         this._recordCount = 0;
@@ -2260,6 +3263,7 @@ const builder = new XMLBuilder(builderOptions);
         // Optimized lookup: Map<fieldIndex, Map<stringValue, sharedItemsIndex>>
         this._sharedItemsIndexMap = new Map();
         this._cacheId = cacheId;
+        this._fileIndex = fileIndex;
         this._sourceSheet = sourceSheet;
         this._sourceRange = sourceRange;
     }
@@ -2269,6 +3273,11 @@ const builder = new XMLBuilder(builderOptions);
         return this._cacheId;
     }
     /**
+   * Get the file index for this cache (used for file naming).
+   */ get fileIndex() {
+        return this._fileIndex;
+    }
+    /**
    * Set refreshOnLoad option
    */ set refreshOnLoad(value) {
         this._refreshOnLoad = value;
@@ -2570,6 +3579,11 @@ const builder = new XMLBuilder(builderOptions);
         this._pivotTables = [];
         this._pivotCaches = [];
         this._nextCacheId = 0;
+        this._nextCacheFileIndex = 1;
+        // Table support
+        this._nextTableId = 1;
+        // Date serialization handling
+        this._dateHandling = 'jsDate';
         this._sharedStrings = new SharedStrings();
         this._styles = Styles.createDefault();
     }
@@ -2634,6 +3648,23 @@ const builder = new XMLBuilder(builderOptions);
         return this._styles;
     }
     /**
+   * Get the workbook date handling strategy.
+   */ get dateHandling() {
+        return this._dateHandling;
+    }
+    /**
+   * Set the workbook date handling strategy.
+   */ set dateHandling(value) {
+        this._dateHandling = value;
+    }
+    /**
+   * Get the next unique table ID for this workbook.
+   * Table IDs must be unique across all worksheets.
+   * @internal
+   */ getNextTableId() {
+        return this._nextTableId++;
+    }
+    /**
    * Get a worksheet by name or index
    */ sheet(nameOrIndex) {
         let def;
@@ -2715,6 +3746,11 @@ const builder = new XMLBuilder(builderOptions);
         const def = this._sheetDefs[index];
         this._sheetDefs.splice(index, 1);
         this._sheets.delete(def.name);
+        const rel = this._relationships.find((r)=>r.id === def.rId);
+        if (rel) {
+            const sheetPath = `xl/${rel.target}`;
+            this._files.delete(sheetPath);
+        }
         // Remove relationship
         const relIndex = this._relationships.findIndex((r)=>r.id === def.rId);
         if (relIndex >= 0) {
@@ -2757,12 +3793,76 @@ const builder = new XMLBuilder(builderOptions);
                 newCell.styleIndex = cell.styleIndex;
             }
         }
+        // Copy column widths
+        for (const [col, width] of source.getColumnWidths()){
+            copy.setColumnWidth(col, width);
+        }
+        // Copy row heights
+        for (const [row, height] of source.getRowHeights()){
+            copy.setRowHeight(row, height);
+        }
+        // Copy frozen panes
+        const frozen = source.getFrozenPane();
+        if (frozen) {
+            copy.freezePane(frozen.row, frozen.col);
+        }
         // Copy merged cells
         for (const mergedRange of source.mergedCells){
             copy.mergeCells(mergedRange);
         }
+        // Copy tables
+        for (const table of source.tables){
+            const tableName = this._createUniqueTableName(table.name, newName);
+            const newTable = copy.createTable({
+                name: tableName,
+                range: table.baseRange,
+                totalRow: table.hasTotalRow,
+                headerRow: table.hasHeaderRow,
+                style: table.style
+            });
+            if (!table.hasAutoFilter) {
+                newTable.setAutoFilter(false);
+            }
+            if (table.hasTotalRow) {
+                for (const columnName of table.columns){
+                    const fn = table.getTotalFunction(columnName);
+                    if (fn) {
+                        newTable.setTotalFunction(columnName, fn);
+                    }
+                }
+            }
+        }
         return copy;
     }
+    _createUniqueTableName(base, sheetName) {
+        const normalizedSheet = sheetName.replace(/[^A-Za-z0-9_.]/g, '_');
+        const sanitizedBase = this._sanitizeTableName(`${base}_${normalizedSheet || 'Sheet'}`);
+        let candidate = sanitizedBase;
+        let counter = 1;
+        while(this._hasTableName(candidate)){
+            candidate = `${sanitizedBase}_${counter++}`;
+        }
+        return candidate;
+    }
+    _sanitizeTableName(name) {
+        let result = name.replace(/[^A-Za-z0-9_.]/g, '_');
+        if (!/^[A-Za-z_]/.test(result)) {
+            result = `_${result}`;
+        }
+        if (result.length === 0) {
+            result = 'Table';
+        }
+        return result;
+    }
+    _hasTableName(name) {
+        for (const sheetName of this.sheetNames){
+            const ws = this.sheet(sheetName);
+            for (const table of ws.tables){
+                if (table.name === name) return true;
+            }
+        }
+        return false;
+    }
     /**
    * Create a new worksheet from an array of objects.
    *
@@ -2934,7 +4034,8 @@ const builder = new XMLBuilder(builderOptions);
         const { headers, data } = this._extractSourceData(sourceWs, sourceRange);
         // Create pivot cache
         const cacheId = this._nextCacheId++;
-        const cache = new PivotCache(cacheId, sourceSheet, sourceRange);
+        const cacheFileIndex = this._nextCacheFileIndex++;
+        const cache = new PivotCache(cacheId, sourceSheet, sourceRange, cacheFileIndex);
         cache.buildFromData(headers, data);
         // refreshOnLoad defaults to true; only disable if explicitly set to false
         if (config.refreshOnLoad === false) {
@@ -2943,7 +4044,7 @@ const builder = new XMLBuilder(builderOptions);
         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);
+        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);
@@ -3042,10 +4143,11 @@ const builder = new XMLBuilder(builderOptions);
         }
     }
     _updateFiles() {
+        const relationshipInfo = this._buildRelationshipInfo();
         // Update workbook.xml
-        this._updateWorkbookXml();
+        this._updateWorkbookXml(relationshipInfo.pivotCacheRelIds);
         // Update relationships
-        this._updateRelationshipsXml();
+        this._updateRelationshipsXml(relationshipInfo.relNodes);
         // Update content types
         this._updateContentTypes();
         // Update shared strings if modified
@@ -3056,9 +4158,9 @@ const builder = new XMLBuilder(builderOptions);
         if (this._styles.dirty || this._dirty || !this._files.has('xl/styles.xml')) {
             writeZipText(this._files, 'xl/styles.xml', this._styles.toXml());
         }
-        // Update worksheets
+        // Update worksheets (needed for pivot table targets)
         for (const [name, worksheet] of this._sheets){
-            if (worksheet.dirty || this._dirty) {
+            if (worksheet.dirty || this._dirty || worksheet.tables.length > 0) {
                 const def = this._sheetDefs.find((s)=>s.name === name);
                 if (def) {
                     const rel = this._relationships.find((r)=>r.id === def.rId);
@@ -3073,8 +4175,23 @@ const builder = new XMLBuilder(builderOptions);
         if (this._pivotTables.length > 0) {
             this._updatePivotTableFiles();
         }
+        // Update tables (sets table rel IDs for tableParts)
+        this._updateTableFiles();
+        // Update worksheets to align tableParts with relationship IDs
+        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);
+                if (def) {
+                    const rel = this._relationships.find((r)=>r.id === def.rId);
+                    if (rel) {
+                        const sheetPath = `xl/${rel.target}`;
+                        writeZipText(this._files, sheetPath, worksheet.toXml());
+                    }
+                }
+            }
+        }
     }
-    _updateWorkbookXml() {
+    _updateWorkbookXml(pivotCacheRelIds) {
         const sheetNodes = this._sheetDefs.map((def)=>createElement('sheet', {
                 name: def.name,
                 sheetId: String(def.sheetId),
@@ -3086,9 +4203,11 @@ const builder = new XMLBuilder(builderOptions);
         ];
         // Add pivot caches if any
         if (this._pivotCaches.length > 0) {
-            const pivotCacheNodes = this._pivotCaches.map((cache, idx)=>{
-                // Cache relationship ID is after sheets, sharedStrings, and styles
-                const cacheRelId = `rId${this._relationships.length + 3 + idx}`;
+            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
@@ -3105,20 +4224,38 @@ const builder = new XMLBuilder(builderOptions);
         ])}`;
         writeZipText(this._files, 'xl/workbook.xml', xml);
     }
-    _updateRelationshipsXml() {
+    _updateRelationshipsXml(relNodes) {
+        const relsNode = createElement('Relationships', {
+            xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
+        }, relNodes);
+        const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
+            relsNode
+        ])}`;
+        writeZipText(this._files, 'xl/_rels/workbook.xml.rels', xml);
+    }
+    _buildRelationshipInfo() {
         const relNodes = this._relationships.map((rel)=>createElement('Relationship', {
                 Id: rel.id,
                 Type: rel.type,
                 Target: rel.target
             }, []));
-        // Calculate next available relationship ID based on existing max ID
+        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 = ()=>{
+            while(reservedRelIds.has(`rId${nextRelId}`)){
+                nextRelId++;
+            }
+            const id = `rId${nextRelId}`;
+            nextRelId++;
+            reservedRelIds.add(id);
+            return id;
+        };
         // Add shared strings relationship if needed
         if (this._sharedStrings.count > 0) {
             const hasSharedStrings = this._relationships.some((r)=>r.type === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings');
             if (!hasSharedStrings) {
                 relNodes.push(createElement('Relationship', {
-                    Id: `rId${nextRelId++}`,
+                    Id: allocateRelId(),
                     Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings',
                     Target: 'sharedStrings.xml'
                 }, []));
@@ -3128,26 +4265,26 @@ const builder = new XMLBuilder(builderOptions);
         const hasStyles = this._relationships.some((r)=>r.type === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles');
         if (!hasStyles) {
             relNodes.push(createElement('Relationship', {
-                Id: `rId${nextRelId++}`,
+                Id: allocateRelId(),
                 Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles',
                 Target: 'styles.xml'
             }, []));
         }
         // Add pivot cache relationships
-        for(let i = 0; i < this._pivotCaches.length; i++){
+        const pivotCacheRelIds = new Map();
+        for (const cache of this._pivotCaches){
+            const id = allocateRelId();
+            pivotCacheRelIds.set(cache.cacheId, id);
             relNodes.push(createElement('Relationship', {
-                Id: `rId${nextRelId++}`,
+                Id: id,
                 Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
-                Target: `pivotCache/pivotCacheDefinition${i + 1}.xml`
+                Target: `pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`
             }, []));
         }
-        const relsNode = createElement('Relationships', {
-            xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
-        }, relNodes);
-        const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
-            relsNode
-        ])}`;
-        writeZipText(this._files, 'xl/_rels/workbook.xml.rels', xml);
+        return {
+            relNodes,
+            pivotCacheRelIds
+        };
     }
     _updateContentTypes() {
         const types = [
@@ -3186,23 +4323,67 @@ const builder = new XMLBuilder(builderOptions);
             }
         }
         // Add pivot cache definitions and records
-        for(let i = 0; i < this._pivotCaches.length; i++){
+        for (const cache of this._pivotCaches){
             types.push(createElement('Override', {
-                PartName: `/xl/pivotCache/pivotCacheDefinition${i + 1}.xml`,
+                PartName: `/xl/pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`,
                 ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml'
             }, []));
             types.push(createElement('Override', {
-                PartName: `/xl/pivotCache/pivotCacheRecords${i + 1}.xml`,
+                PartName: `/xl/pivotCache/pivotCacheRecords${cache.fileIndex}.xml`,
                 ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml'
             }, []));
         }
         // Add pivot tables
-        for(let i = 0; i < this._pivotTables.length; i++){
+        for (const pivotTable of this._pivotTables){
             types.push(createElement('Override', {
-                PartName: `/xl/pivotTables/pivotTable${i + 1}.xml`,
+                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){
+            const worksheet = this._sheets.get(def.name);
+            if (worksheet) {
+                for(let i = 0; i < worksheet.tables.length; i++){
+                    types.push(createElement('Override', {
+                        PartName: `/xl/tables/table${tableIndex}.xml`,
+                        ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml'
+                    }, []));
+                    tableIndex++;
+                }
+            }
+        }
+        const existingTypesXml = readZipText(this._files, '[Content_Types].xml');
+        const existingKeys = new Set(types.map((t)=>{
+            if ('Default' in t) {
+                const a = t[':@'];
+                return `Default:${a?.['@_Extension'] || ''}`;
+            }
+            if ('Override' in t) {
+                const a = t[':@'];
+                return `Override:${a?.['@_PartName'] || ''}`;
+            }
+            return '';
+        }).filter(Boolean));
+        if (existingTypesXml) {
+            const parsed = parseXml(existingTypesXml);
+            const typesElement = findElement(parsed, 'Types');
+            if (typesElement) {
+                const existingNodes = getChildren(typesElement, 'Types');
+                for (const node of existingNodes){
+                    if ('Default' in node || 'Override' in node) {
+                        const type = 'Default' in node ? 'Default' : 'Override';
+                        const attrs = node[':@'];
+                        const key = type === 'Default' ? `Default:${attrs?.['@_Extension'] || ''}` : `Override:${attrs?.['@_PartName'] || ''}`;
+                        if (!existingKeys.has(key)) {
+                            types.push(node);
+                            existingKeys.add(key);
+                        }
+                    }
+                }
+            }
+        }
         const typesNode = createElement('Types', {
             xmlns: 'http://schemas.openxmlformats.org/package/2006/content-types'
         }, types);
@@ -3242,22 +4423,21 @@ const builder = new XMLBuilder(builderOptions);
         // Generate pivot cache files
         for(let i = 0; i < this._pivotCaches.length; i++){
             const cache = this._pivotCaches[i];
-            const cacheIdx = i + 1;
             // Pivot cache definition
-            const definitionPath = `xl/pivotCache/pivotCacheDefinition${cacheIdx}.xml`;
+            const definitionPath = `xl/pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`;
             writeZipText(this._files, definitionPath, cache.toDefinitionXml('rId1'));
             // Pivot cache records
-            const recordsPath = `xl/pivotCache/pivotCacheRecords${cacheIdx}.xml`;
+            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${cacheIdx}.xml.rels`;
+            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${cacheIdx}.xml`
+                    Target: `pivotCacheRecords${cache.fileIndex}.xml`
                 }, [])
             ]);
             writeZipText(this._files, cacheRelsPath, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
@@ -3267,12 +4447,12 @@ const builder = new XMLBuilder(builderOptions);
         // Generate pivot table files
         for(let i = 0; i < this._pivotTables.length; i++){
             const pivotTable = this._pivotTables[i];
-            const ptIdx = i + 1;
+            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 = this._pivotCaches.indexOf(pivotTable.cache) + 1;
+            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'
@@ -3296,13 +4476,47 @@ const builder = new XMLBuilder(builderOptions);
             // Extract sheet file name from target path
             const sheetFileName = rel.target.split('/').pop();
             const sheetRelsPath = `xl/worksheets/_rels/${sheetFileName}.rels`;
-            const relNodes = [];
-            for(let i = 0; i < pivotTables.length; i++){
-                const pt = pivotTables[i];
+            const existingRelsXml = readZipText(this._files, sheetRelsPath);
+            let relNodes = [];
+            let nextRelId = 1;
+            const reservedRelIds = new Set();
+            if (existingRelsXml) {
+                const parsed = parseXml(existingRelsXml);
+                const relsElement = findElement(parsed, 'Relationships');
+                if (relsElement) {
+                    const existingRelNodes = getChildren(relsElement, 'Relationships');
+                    for (const relNode of existingRelNodes){
+                        if ('Relationship' in relNode) {
+                            relNodes.push(relNode);
+                            const id = getAttr(relNode, 'Id');
+                            if (id) {
+                                reservedRelIds.add(id);
+                                const idNum = parseInt(id.replace('rId', ''), 10);
+                                if (idNum >= nextRelId) {
+                                    nextRelId = idNum + 1;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const allocateRelId = ()=>{
+                while(reservedRelIds.has(`rId${nextRelId}`)){
+                    nextRelId++;
+                }
+                const id = `rId${nextRelId}`;
+                nextRelId++;
+                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;
                 relNodes.push(createElement('Relationship', {
-                    Id: `rId${i + 1}`,
+                    Id: allocateRelId(),
                     Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable',
-                    Target: `../pivotTables/pivotTable${pt.index}.xml`
+                    Target: target
                 }, []));
             }
             const sheetRels = createElement('Relationships', {
@@ -3313,6 +4527,109 @@ const builder = new XMLBuilder(builderOptions);
             ])}`);
         }
     }
+    /**
+   * 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 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);
+            if (!rel) continue;
+            // 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 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){
+                        if ('Relationship' in relNode) {
+                            relNodes.push(relNode);
+                            const id = getAttr(relNode, 'Id');
+                            if (id) {
+                                reservedRelIds.add(id);
+                                const idNum = parseInt(id.replace('rId', ''), 10);
+                                if (idNum >= nextRelId) {
+                                    nextRelId = idNum + 1;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const allocateRelId = ()=>{
+                while(reservedRelIds.has(`rId${nextRelId}`)){
+                    nextRelId++;
+                }
+                const id = `rId${nextRelId}`;
+                nextRelId++;
+                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);
+                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: 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);
+            writeZipText(this._files, sheetRelsPath, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([
+                sheetRels
+            ])}`);
+        }
+    }
 }
 
-export { Cell, PivotCache, PivotTable, Range, SharedStrings, Styles, Workbook, Worksheet, parseAddress, parseRange, toAddress, toRange };
+export { Cell, PivotCache, PivotTable, Range, SharedStrings, Styles, Table, Workbook, Worksheet, parseAddress, parseRange, toAddress, toRange };