@cj-tech-master/excelts 1.6.3 → 2.0.0-canary.20251228013952.4f2c3c6

package/dist/esm/xlsx/xlsx.js

@@ -1,27 +1,21 @@
+/**
+ * XLSX - Node.js version with full functionality
+ *
+ * Extends XLSXBase with:
+ * - readFile: Read from file path
+ * - writeFile: Write to file path
+ * - read: Read from stream
+ * - write: Write to stream
+ * - load: Load from buffer
+ * - writeBuffer: Write to buffer
+ */
 import fs from "fs";
-import { Unzip, UnzipInflate } from "fflate";
 import { PassThrough } from "stream";
+import { ZipParser } from "../utils/unzip/zip-parser.js";
 import { ZipWriter } from "../utils/zip-stream.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { fileExists, bufferToString } from "../utils/utils.js";
-import { XmlStream } from "../utils/xml-stream.js";
-import { StylesXform } from "./xform/style/styles-xform.js";
-import { CoreXform } from "./xform/core/core-xform.js";
-import { SharedStringsXform } from "./xform/strings/shared-strings-xform.js";
-import { RelationshipsXform } from "./xform/core/relationships-xform.js";
-import { ContentTypesXform } from "./xform/core/content-types-xform.js";
-import { AppXform } from "./xform/core/app-xform.js";
-import { WorkbookXform } from "./xform/book/workbook-xform.js";
-import { WorkSheetXform } from "./xform/sheet/worksheet-xform.js";
-import { DrawingXform } from "./xform/drawing/drawing-xform.js";
-import { TableXform } from "./xform/table/table-xform.js";
-import { PivotCacheRecordsXform } from "./xform/pivot-table/pivot-cache-records-xform.js";
-import { PivotCacheDefinitionXform } from "./xform/pivot-table/pivot-cache-definition-xform.js";
-import { PivotTableXform } from "./xform/pivot-table/pivot-table-xform.js";
-import { CommentsXform } from "./xform/comment/comments-xform.js";
-import { VmlNotesXform } from "./xform/comment/vml-notes-xform.js";
-import { theme1Xml } from "./xml/theme1.js";
-import { RelType } from "./rel-type.js";
+import { XLSXBase } from "./xlsx.base.js";
 function fsReadFileAsync(filename, options) {
     return new Promise((resolve, reject) => {
         fs.readFile(filename, options, (error, data) => {
@@ -34,14 +28,32 @@ function fsReadFileAsync(filename, options) {
         });
     });
 }
-class XLSX {
-    constructor(workbook) {
-        this.workbook = workbook;
-    }
-    // ===============================================================================
-    // Workbook
-    // =========================================================================
-    // Read
+class XLSX extends XLSXBase {
+    // ===========================================================================
+    // Abstract method implementations
+    // ===========================================================================
+    createStreamBuf() {
+        return new StreamBuf();
+    }
+    createBinaryStream(data) {
+        const stream = new PassThrough();
+        stream.end(Buffer.from(data));
+        return stream;
+    }
+    createTextStream(content) {
+        const stream = new PassThrough({
+            readableObjectMode: true,
+            writableObjectMode: true
+        });
+        stream.end(content);
+        return stream;
+    }
+    bufferToString(data) {
+        return bufferToString(data);
+    }
+    // ===========================================================================
+    // Node.js specific: File operations
+    // ===========================================================================
     async readFile(filename, options) {
         if (!(await fileExists(filename))) {
             throw new Error(`File not found: ${filename}`);
@@ -57,425 +69,102 @@ class XLSX {
             throw error;
         }
     }
-    parseRels(stream) {
-        const xform = new RelationshipsXform();
-        return xform.parseStream(stream);
-    }
-    parseWorkbook(stream) {
-        const xform = new WorkbookXform();
-        return xform.parseStream(stream);
-    }
-    parseSharedStrings(stream) {
-        const xform = new SharedStringsXform();
-        return xform.parseStream(stream);
-    }
-    reconcile(model, options) {
-        const workbookXform = new WorkbookXform();
-        const worksheetXform = new WorkSheetXform(options);
-        const drawingXform = new DrawingXform();
-        const tableXform = new TableXform();
-        workbookXform.reconcile(model);
-        // reconcile drawings with their rels
-        const drawingOptions = {
-            media: model.media,
-            mediaIndex: model.mediaIndex
-        };
-        Object.keys(model.drawings).forEach(name => {
-            const drawing = model.drawings[name];
-            const drawingRel = model.drawingRels[name];
-            if (drawingRel) {
-                drawingOptions.rels = drawingRel.reduce((o, rel) => {
-                    o[rel.Id] = rel;
-                    return o;
-                }, {});
-                (drawing.anchors || []).forEach((anchor) => {
-                    const hyperlinks = anchor.picture && anchor.picture.hyperlinks;
-                    if (hyperlinks && drawingOptions.rels[hyperlinks.rId]) {
-                        hyperlinks.hyperlink = drawingOptions.rels[hyperlinks.rId].Target;
-                        delete hyperlinks.rId;
-                    }
-                });
-                drawingXform.reconcile(drawing, drawingOptions);
-            }
-        });
-        // reconcile tables with the default styles
-        const tableOptions = {
-            styles: model.styles
-        };
-        Object.values(model.tables).forEach((table) => {
-            tableXform.reconcile(table, tableOptions);
-        });
-        // Reconcile pivot tables - link pivot tables to worksheets and cache data
-        this._reconcilePivotTables(model);
-        const sheetOptions = {
-            styles: model.styles,
-            sharedStrings: model.sharedStrings,
-            media: model.media,
-            mediaIndex: model.mediaIndex,
-            date1904: model.properties && model.properties.date1904,
-            drawings: model.drawings,
-            comments: model.comments,
-            tables: model.tables,
-            vmlDrawings: model.vmlDrawings,
-            pivotTables: model.pivotTablesIndexed
-        };
-        model.worksheets.forEach((worksheet) => {
-            worksheet.relationships = model.worksheetRels[worksheet.sheetNo];
-            worksheetXform.reconcile(worksheet, sheetOptions);
-        });
-        // delete unnecessary parts
-        delete model.worksheetHash;
-        delete model.worksheetRels;
-        delete model.globalRels;
-        delete model.sharedStrings;
-        delete model.workbookRels;
-        delete model.sheetDefs;
-        delete model.styles;
-        delete model.mediaIndex;
-        delete model.drawings;
-        delete model.drawingRels;
-        delete model.vmlDrawings;
-        // Clean up raw pivot table data after reconciliation
-        delete model.pivotTableRels;
-        delete model.pivotCacheDefinitionRels;
-    }
-    /**
-     * Reconcile pivot tables by linking them to worksheets and their cache data.
-     * This builds a complete pivot table model ready for writing.
-     */
-    _reconcilePivotTables(model) {
-        // Skip if no pivot tables were loaded (object is empty or undefined)
-        const rawPivotTables = model.pivotTables || {};
-        if (typeof rawPivotTables !== "object" || Object.keys(rawPivotTables).length === 0) {
-            // Ensure pivotTables is an empty array (not an object)
-            model.pivotTables = [];
-            // Also create an empty indexed object for worksheet reconciliation
-            model.pivotTablesIndexed = {};
-            return;
-        }
-        // Build mapping from definition name to cacheId
-        const definitionToCacheId = this._buildDefinitionToCacheIdMap(model);
-        // Build a map of cache IDs to their definitions and records
-        const cacheMap = new Map();
-        // Process cache definitions
-        Object.entries(model.pivotCacheDefinitions || {}).forEach(([name, definition]) => {
-            // Get the cacheId from the mapping (derived from workbook.xml pivotCaches)
-            const cacheId = definitionToCacheId.get(name);
-            if (cacheId !== undefined) {
-                const recordsName = name.replace("Definition", "Records");
-                cacheMap.set(cacheId, {
-                    definition,
-                    records: model.pivotCacheRecords?.[recordsName],
-                    definitionName: name
-                });
-            }
-        });
-        // Process pivot tables and link to worksheets
-        const loadedPivotTables = [];
-        // Create indexed object for worksheet reconciliation (keyed by relative path)
-        const pivotTablesIndexed = {};
-        Object.entries(rawPivotTables).forEach(([pivotName, pivotTable]) => {
-            const pt = pivotTable;
-            const tableNumber = this._extractTableNumber(pivotName);
-            // Get cache data for this pivot table
-            const cacheData = cacheMap.get(pt.cacheId);
-            // Build complete pivot table model
-            const completePivotTable = {
-                // Core model data
-                ...pt,
-                tableNumber,
-                // Link to cache data
-                cacheDefinition: cacheData?.definition,
-                cacheRecords: cacheData?.records,
-                // Reconstruct cacheFields from definition for compatibility
-                cacheFields: cacheData?.definition?.cacheFields || [],
-                // Determine rows, columns, values from parsed data
-                rows: pt.rowFields.filter(f => f >= 0),
-                columns: pt.colFields.filter(f => f >= 0 && f !== -2),
-                values: pt.dataFields.map(df => df.fld),
-                // Determine metric from dataFields
-                metric: this._determineMetric(pt.dataFields),
-                // Preserve formatting options
-                applyWidthHeightFormats: pt.applyWidthHeightFormats || "0"
-            };
-            loadedPivotTables.push(completePivotTable);
-            // Index by relative path for worksheet reconciliation
-            pivotTablesIndexed[`../pivotTables/${pivotName}.xml`] = completePivotTable;
-        });
-        // Sort by table number to maintain order
-        loadedPivotTables.sort((a, b) => a.tableNumber - b.tableNumber);
-        // Replace pivotTables object with the processed array
-        // This is what the Workbook model setter expects
-        model.pivotTables = loadedPivotTables;
-        // Also keep indexed version for worksheet reconciliation
-        model.pivotTablesIndexed = pivotTablesIndexed;
-        // Also keep as loadedPivotTables for backward compatibility
-        model.loadedPivotTables = loadedPivotTables;
-    }
-    /**
-     * Extract table number from pivot table name (e.g., "pivotTable1" -> 1)
-     */
-    _extractTableNumber(name) {
-        const match = name.match(/pivotTable(\d+)/);
-        return match ? parseInt(match[1], 10) : 1;
-    }
-    /**
-     * Build a mapping from rId to cacheId using pivotCaches from workbook.xml
-     * and workbookRels to determine which definition file corresponds to which cacheId
-     */
-    _buildCacheIdMap(model) {
-        const rIdToCacheId = new Map();
-        // pivotCaches from workbook.xml contains {cacheId, rId} mappings
-        const pivotCaches = model.pivotCaches || [];
-        for (const cache of pivotCaches) {
-            if (cache.cacheId && cache.rId) {
-                rIdToCacheId.set(cache.rId, parseInt(cache.cacheId, 10));
-            }
-        }
-        return rIdToCacheId;
-    }
-    /**
-     * Build a mapping from definition name to cacheId
-     */
-    _buildDefinitionToCacheIdMap(model) {
-        const definitionToCacheId = new Map();
-        const rIdToCacheId = this._buildCacheIdMap(model);
-        const workbookRels = model.workbookRels || [];
-        // Map workbook rels to get definitionNumber -> cacheId mapping
-        for (const rel of workbookRels) {
-            if (rel.Type === XLSX.RelType.PivotCacheDefinition && rel.Target) {
-                // Extract definition number from target (e.g., "pivotCache/pivotCacheDefinition1.xml" -> 1)
-                const match = rel.Target.match(/pivotCacheDefinition(\d+)\.xml/);
-                if (match) {
-                    const defName = `pivotCacheDefinition${match[1]}`;
-                    const cacheId = rIdToCacheId.get(rel.Id);
-                    if (cacheId !== undefined) {
-                        definitionToCacheId.set(defName, cacheId);
-                    }
-                }
-            }
-        }
-        return definitionToCacheId;
-    }
-    /**
-     * Determine the aggregation metric from dataFields
-     */
-    _determineMetric(dataFields) {
-        if (dataFields.length > 0 && dataFields[0].subtotal === "count") {
-            return "count";
-        }
-        return "sum";
-    }
-    async _processWorksheetEntry(stream, model, sheetNo, options, path) {
-        const xform = new WorkSheetXform(options);
-        const worksheet = await xform.parseStream(stream);
-        if (!worksheet) {
-            throw new Error(`Failed to parse worksheet ${path}`);
-        }
-        worksheet.sheetNo = sheetNo;
-        model.worksheetHash[path] = worksheet;
-        model.worksheets.push(worksheet);
-    }
-    async _processCommentEntry(stream, model, name) {
-        const xform = new CommentsXform();
-        const comments = await xform.parseStream(stream);
-        model.comments[`../${name}.xml`] = comments;
-    }
-    async _processTableEntry(stream, model, name) {
-        const xform = new TableXform();
-        const table = await xform.parseStream(stream);
-        model.tables[`../tables/${name}.xml`] = table;
-    }
-    async _processWorksheetRelsEntry(stream, model, sheetNo) {
-        const xform = new RelationshipsXform();
-        const relationships = await xform.parseStream(stream);
-        model.worksheetRels[sheetNo] = relationships;
-    }
-    async _processMediaEntry(stream, model, filename) {
-        const lastDot = filename.lastIndexOf(".");
-        // if we can't determine extension, ignore it
-        if (lastDot >= 1) {
-            const extension = filename.substr(lastDot + 1);
-            const name = filename.substr(0, lastDot);
-            await new Promise((resolve, reject) => {
-                const streamBuf = new StreamBuf();
-                const cleanup = () => {
-                    stream.removeListener("error", onError);
-                    streamBuf.removeListener("error", onError);
-                    streamBuf.removeListener("finish", onFinish);
-                };
-                const onFinish = () => {
-                    cleanup();
-                    model.mediaIndex[filename] = model.media.length;
-                    model.mediaIndex[name] = model.media.length;
-                    const medium = {
-                        type: "image",
-                        name,
-                        extension,
-                        buffer: streamBuf.toBuffer()
-                    };
-                    model.media.push(medium);
-                    resolve();
-                };
-                const onError = (error) => {
-                    cleanup();
-                    reject(error);
-                };
-                streamBuf.once("finish", onFinish);
-                stream.on("error", onError);
-                streamBuf.on("error", onError);
-                stream.pipe(streamBuf);
-            });
-        }
-    }
-    async _processDrawingEntry(entry, model, name) {
-        const xform = new DrawingXform();
-        const drawing = await xform.parseStream(entry);
-        model.drawings[name] = drawing;
-    }
-    async _processDrawingRelsEntry(entry, model, name) {
-        const xform = new RelationshipsXform();
-        const relationships = await xform.parseStream(entry);
-        model.drawingRels[name] = relationships;
-    }
-    async _processVmlDrawingEntry(entry, model, name) {
-        const xform = new VmlNotesXform();
-        const vmlDrawing = await xform.parseStream(entry);
-        model.vmlDrawings[`../drawings/${name}.vml`] = vmlDrawing;
-    }
-    async _processThemeEntry(stream, model, name) {
-        await new Promise((resolve, reject) => {
-            // TODO: stream entry into buffer and store the xml in the model.themes[]
-            const streamBuf = new StreamBuf();
+    writeFile(filename, options) {
+        const stream = fs.createWriteStream(filename);
+        return new Promise((resolve, reject) => {
             const cleanup = () => {
+                stream.removeListener("finish", onFinish);
                 stream.removeListener("error", onError);
-                streamBuf.removeListener("error", onError);
-                streamBuf.removeListener("finish", onFinish);
             };
             const onFinish = () => {
                 cleanup();
-                model.themes[name] = streamBuf.read().toString();
                 resolve();
             };
-            const onError = (err) => {
+            const onError = (error) => {
                 cleanup();
-                reject(err);
+                reject(error);
             };
-            streamBuf.once("finish", onFinish);
+            stream.once("finish", onFinish);
             stream.on("error", onError);
-            streamBuf.on("error", onError);
-            stream.pipe(streamBuf);
+            this.write(stream, options)
+                .then(() => {
+                stream.end();
+            })
+                .catch(err => {
+                cleanup();
+                reject(err);
+            });
         });
     }
-    async _processPivotTableEntry(stream, model, name) {
-        const xform = new PivotTableXform();
-        const pivotTable = await xform.parseStream(stream);
-        if (pivotTable) {
-            model.pivotTables[name] = pivotTable;
-        }
-    }
-    async _processPivotTableRelsEntry(stream, model, name) {
-        const xform = new RelationshipsXform();
-        const relationships = await xform.parseStream(stream);
-        model.pivotTableRels[name] = relationships;
-    }
-    async _processPivotCacheDefinitionEntry(stream, model, name) {
-        const xform = new PivotCacheDefinitionXform();
-        const cacheDefinition = await xform.parseStream(stream);
-        if (cacheDefinition) {
-            model.pivotCacheDefinitions[name] = cacheDefinition;
-        }
-    }
-    async _processPivotCacheDefinitionRelsEntry(stream, model, name) {
-        const xform = new RelationshipsXform();
-        const relationships = await xform.parseStream(stream);
-        model.pivotCacheDefinitionRels[name] = relationships;
-    }
-    async _processPivotCacheRecordsEntry(stream, model, name) {
-        const xform = new PivotCacheRecordsXform();
-        const cacheRecords = await xform.parseStream(stream);
-        if (cacheRecords) {
-            model.pivotCacheRecords[name] = cacheRecords;
-        }
-    }
+    // ===========================================================================
+    // Node.js specific: Stream operations
+    // ===========================================================================
     async read(stream, options) {
-        // Use streaming unzip with fflate
-        const allFiles = {};
+        // Collect all stream data into a single buffer
+        const chunks = [];
         await new Promise((resolve, reject) => {
-            let filesProcessed = 0;
-            let zipEnded = false;
-            let filesStarted = 0;
-            const cleanup = () => {
-                stream.removeListener("data", onData);
-                stream.removeListener("end", onEnd);
-                stream.removeListener("error", onError);
-            };
-            const checkCompletion = () => {
-                if (zipEnded && filesProcessed === filesStarted) {
-                    cleanup();
-                    resolve();
-                }
-            };
-            const unzipper = new Unzip((file) => {
-                filesStarted++;
-                const fileChunks = [];
-                let totalLength = 0;
-                file.ondata = (err, data, final) => {
-                    if (err) {
-                        cleanup();
-                        reject(err);
-                        return;
-                    }
-                    if (data) {
-                        fileChunks.push(data);
-                        totalLength += data.length;
-                    }
-                    if (final) {
-                        // Optimize for single chunk case
-                        if (fileChunks.length === 1) {
-                            allFiles[file.name] = fileChunks[0];
-                        }
-                        else if (fileChunks.length > 1) {
-                            const fullData = new Uint8Array(totalLength);
-                            let offset = 0;
-                            for (const chunk of fileChunks) {
-                                fullData.set(chunk, offset);
-                                offset += chunk.length;
-                            }
-                            allFiles[file.name] = fullData;
-                        }
-                        else {
-                            allFiles[file.name] = new Uint8Array(0);
-                        }
-                        filesProcessed++;
-                        fileChunks.length = 0;
-                        checkCompletion();
-                    }
-                };
-                file.start();
-            });
-            unzipper.register(UnzipInflate);
             const onData = (chunk) => {
-                unzipper.push(chunk);
+                chunks.push(chunk);
             };
             const onEnd = () => {
-                unzipper.push(new Uint8Array(0), true);
-                zipEnded = true;
-                checkCompletion();
+                stream.removeListener("data", onData);
+                stream.removeListener("end", onEnd);
+                stream.removeListener("error", onError);
+                resolve();
             };
             const onError = (err) => {
-                cleanup();
+                stream.removeListener("data", onData);
+                stream.removeListener("end", onEnd);
+                stream.removeListener("error", onError);
                 reject(err);
             };
             stream.on("data", onData);
             stream.on("end", onEnd);
             stream.on("error", onError);
         });
+        // Combine chunks into a single buffer
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const buffer = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            buffer.set(chunk, offset);
+            offset += chunk.length;
+        }
+        // Use native ZipParser for extraction
+        const parser = new ZipParser(buffer);
+        const filesMap = await parser.extractAll();
+        // Convert Map to Record for loadFromFiles
+        const allFiles = {};
+        for (const [path, content] of filesMap) {
+            allFiles[path] = content;
+        }
         return this.loadFromFiles(allFiles, options);
     }
+    async write(stream, options) {
+        options = options || {};
+        const { model } = this.workbook;
+        const zip = new ZipWriter(options.zip);
+        zip.pipe(stream);
+        this.prepareModel(model, options);
+        await this.addContentTypes(zip, model);
+        await this.addOfficeRels(zip, model);
+        await this.addWorkbookRels(zip, model);
+        await this.addWorksheets(zip, model);
+        await this.addSharedStrings(zip, model);
+        this.addDrawings(zip, model);
+        this.addTables(zip, model);
+        this.addPivotTables(zip, model);
+        await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
+        await this.addMedia(zip, model);
+        await Promise.all([this.addApp(zip, model), this.addCore(zip, model)]);
+        await this.addWorkbook(zip, model);
+        return this._finalize(zip);
+    }
+    // ===========================================================================
+    // Node.js specific: Buffer operations
+    // ===========================================================================
     async load(data, options) {
         let buffer;
-        // Validate input type
         if (!data ||
             (typeof data === "object" &&
                 !Buffer.isBuffer(data) &&
@@ -489,299 +178,18 @@ class XLSX {
         else {
             buffer = data;
         }
-        // Create a fake stream from buffer for consistency
-        const PassThroughStream = PassThrough;
-        const stream = new PassThroughStream();
+        const stream = new PassThrough();
         stream.end(buffer);
         return this.read(stream, options);
     }
-    async loadFromFiles(zipData, options) {
-        const model = {
-            worksheets: [],
-            worksheetHash: {},
-            worksheetRels: [],
-            themes: {},
-            media: [],
-            mediaIndex: {},
-            drawings: {},
-            drawingRels: {},
-            comments: {},
-            tables: {},
-            vmlDrawings: {},
-            // Pivot table storage for loaded files
-            pivotTables: {},
-            pivotTableRels: {},
-            pivotCacheDefinitions: {},
-            pivotCacheDefinitionRels: {},
-            pivotCacheRecords: {}
-        };
-        // Convert fflate format to JSZip-like structure for compatibility
-        const entries = Object.keys(zipData).map(name => ({
-            name,
-            dir: name.endsWith("/"),
-            data: zipData[name]
-        }));
-        for (const entry of entries) {
-            if (!entry.dir) {
-                let entryName = entry.name;
-                if (entryName[0] === "/") {
-                    entryName = entryName.substr(1);
-                }
-                let stream;
-                if (entryName.match(/xl\/media\//) ||
-                    // themes are not parsed as stream
-                    entryName.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/)) {
-                    stream = new PassThrough();
-                    stream.end(Buffer.from(entry.data));
-                }
-                else {
-                    // use object mode to avoid buffer-string convention
-                    stream = new PassThrough({
-                        readableObjectMode: true,
-                        writableObjectMode: true
-                    });
-                    const content = bufferToString(Buffer.from(entry.data));
-                    stream.end(content);
-                }
-                let match;
-                match = entryName.match(/xl\/worksheets\/sheet(\d+)[.]xml/);
-                if (match) {
-                    const sheetNo = parseInt(match[1], 10);
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                }
-                else {
-                    switch (entryName) {
-                        case "_rels/.rels":
-                            model.globalRels = await this.parseRels(stream);
-                            break;
-                        case "xl/workbook.xml": {
-                            const workbook = await this.parseWorkbook(stream);
-                            model.sheets = workbook.sheets;
-                            model.definedNames = workbook.definedNames;
-                            model.views = workbook.views;
-                            model.properties = workbook.properties;
-                            model.calcProperties = workbook.calcProperties;
-                            // pivotCaches contains the mapping from rId to cacheId
-                            // needed for linking pivot tables to their cache data
-                            model.pivotCaches = workbook.pivotCaches;
-                            break;
-                        }
-                        case "xl/sharedStrings.xml":
-                            model.sharedStrings = new SharedStringsXform();
-                            await model.sharedStrings.parseStream(stream);
-                            break;
-                        case "xl/_rels/workbook.xml.rels":
-                            model.workbookRels = await this.parseRels(stream);
-                            break;
-                        case "docProps/app.xml": {
-                            const appXform = new AppXform();
-                            const appProperties = await appXform.parseStream(stream);
-                            model.company = appProperties.company;
-                            model.manager = appProperties.manager;
-                            break;
-                        }
-                        case "docProps/core.xml": {
-                            const coreXform = new CoreXform();
-                            const coreProperties = await coreXform.parseStream(stream);
-                            Object.assign(model, coreProperties);
-                            break;
-                        }
-                        case "xl/styles.xml":
-                            model.styles = new StylesXform();
-                            await model.styles.parseStream(stream);
-                            break;
-                        default: {
-                            match = entryName.match(/xl\/worksheets\/_rels\/sheet(\d+)[.]xml[.]rels/);
-                            if (match) {
-                                const sheetNo = parseInt(match[1], 10);
-                                await this._processWorksheetRelsEntry(stream, model, sheetNo);
-                                break;
-                            }
-                            match = entryName.match(/xl\/media\/([a-zA-Z0-9]+[.][a-zA-Z0-9]{3,4})$/);
-                            if (match) {
-                                await this._processMediaEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/drawings\/(drawing\d+)[.]xml/);
-                            if (match) {
-                                await this._processDrawingEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/drawings\/_rels\/(drawing\d+)[.]xml[.]rels/);
-                            if (match) {
-                                await this._processDrawingRelsEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/drawings\/(vmlDrawing\d+)[.]vml/);
-                            if (match) {
-                                await this._processVmlDrawingEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/comments(\d+)[.]xml/);
-                            if (match) {
-                                await this._processCommentEntry(stream, model, `comments${match[1]}`);
-                                break;
-                            }
-                            match = entryName.match(/xl\/tables\/(table\d+)[.]xml/);
-                            if (match) {
-                                await this._processTableEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/);
-                            if (match) {
-                                await this._processThemeEntry(stream, model, match[1]);
-                                break;
-                            }
-                            // Pivot table files
-                            match = entryName.match(/xl\/pivotTables\/(pivotTable\d+)[.]xml/);
-                            if (match) {
-                                await this._processPivotTableEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels/);
-                            if (match) {
-                                await this._processPivotTableRelsEntry(stream, model, match[1]);
-                                break;
-                            }
-                            // Pivot cache files
-                            match = entryName.match(/xl\/pivotCache\/(pivotCacheDefinition\d+)[.]xml/);
-                            if (match) {
-                                await this._processPivotCacheDefinitionEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/pivotCache\/_rels\/(pivotCacheDefinition\d+)[.]xml[.]rels/);
-                            if (match) {
-                                await this._processPivotCacheDefinitionRelsEntry(stream, model, match[1]);
-                                break;
-                            }
-                            match = entryName.match(/xl\/pivotCache\/(pivotCacheRecords\d+)[.]xml/);
-                            if (match) {
-                                await this._processPivotCacheRecordsEntry(stream, model, match[1]);
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        this.reconcile(model, options);
-        // apply model
-        this.workbook.model = model;
-        return this.workbook;
-    }
-    // =========================================================================
-    // Write
-    async addContentTypes(zip, model) {
-        const xform = new ContentTypesXform();
-        const xml = xform.toXml(model);
-        zip.append(xml, { name: "[Content_Types].xml" });
-    }
-    async addApp(zip, model) {
-        const xform = new AppXform();
-        const xml = xform.toXml(model);
-        zip.append(xml, { name: "docProps/app.xml" });
-    }
-    async addCore(zip, model) {
-        const xform = new CoreXform();
-        zip.append(xform.toXml(model), { name: "docProps/core.xml" });
-    }
-    async addThemes(zip, model) {
-        const themes = model.themes || { theme1: theme1Xml };
-        Object.keys(themes).forEach(name => {
-            const xml = themes[name];
-            const path = `xl/theme/${name}.xml`;
-            zip.append(xml, { name: path });
-        });
-    }
-    async addOfficeRels(zip, _model) {
-        const xform = new RelationshipsXform();
-        const xml = xform.toXml([
-            { Id: "rId1", Type: XLSX.RelType.OfficeDocument, Target: "xl/workbook.xml" },
-            { Id: "rId2", Type: XLSX.RelType.CoreProperties, Target: "docProps/core.xml" },
-            { Id: "rId3", Type: XLSX.RelType.ExtenderProperties, Target: "docProps/app.xml" }
-        ]);
-        zip.append(xml, { name: "_rels/.rels" });
-    }
-    async addWorkbookRels(zip, model) {
-        let count = 1;
-        const relationships = [
-            { Id: `rId${count++}`, Type: XLSX.RelType.Styles, Target: "styles.xml" },
-            { Id: `rId${count++}`, Type: XLSX.RelType.Theme, Target: "theme/theme1.xml" }
-        ];
-        if (model.sharedStrings.count) {
-            relationships.push({
-                Id: `rId${count++}`,
-                Type: XLSX.RelType.SharedStrings,
-                Target: "sharedStrings.xml"
-            });
-        }
-        // Add relationships for all pivot tables
-        (model.pivotTables || []).forEach((pivotTable) => {
-            pivotTable.rId = `rId${count++}`;
-            relationships.push({
-                Id: pivotTable.rId,
-                Type: XLSX.RelType.PivotCacheDefinition,
-                Target: `pivotCache/pivotCacheDefinition${pivotTable.tableNumber}.xml`
-            });
-        });
-        model.worksheets.forEach((worksheet, index) => {
-            // Use sequential index (1-based) for file naming, not worksheet.id (sheetId)
-            // sheetId can be non-sequential (e.g., 1, 3, 5) which would create gaps in filenames
-            worksheet.rId = `rId${count++}`;
-            worksheet.fileIndex = index + 1; // Store for use in addWorksheets and content types
-            relationships.push({
-                Id: worksheet.rId,
-                Type: XLSX.RelType.Worksheet,
-                Target: `worksheets/sheet${worksheet.fileIndex}.xml`
-            });
-        });
-        const xform = new RelationshipsXform();
-        const xml = xform.toXml(relationships);
-        zip.append(xml, { name: "xl/_rels/workbook.xml.rels" });
-    }
-    async addSharedStrings(zip, model) {
-        if (model.sharedStrings && model.sharedStrings.count) {
-            zip.append(model.sharedStrings.xml, { name: "xl/sharedStrings.xml" });
-        }
-    }
-    async addStyles(zip, model) {
-        const { xml } = model.styles;
-        if (xml) {
-            zip.append(xml, { name: "xl/styles.xml" });
-        }
-    }
-    async addWorkbook(zip, model) {
-        const xform = new WorkbookXform();
-        zip.append(xform.toXml(model), { name: "xl/workbook.xml" });
-    }
-    async addWorksheets(zip, model) {
-        // preparation phase
-        const worksheetXform = new WorkSheetXform();
-        const relationshipsXform = new RelationshipsXform();
-        const commentsXform = new CommentsXform();
-        const vmlNotesXform = new VmlNotesXform();
-        // write sheets
-        model.worksheets.forEach((worksheet, index) => {
-            // Use fileIndex if set by addWorkbookRels, otherwise use index + 1
-            const fileIndex = worksheet.fileIndex || index + 1;
-            let xmlStream = new XmlStream();
-            worksheetXform.render(xmlStream, worksheet);
-            zip.append(xmlStream.xml, { name: `xl/worksheets/sheet${fileIndex}.xml` });
-            if (worksheet.rels && worksheet.rels.length) {
-                xmlStream = new XmlStream();
-                relationshipsXform.render(xmlStream, worksheet.rels);
-                zip.append(xmlStream.xml, { name: `xl/worksheets/_rels/sheet${fileIndex}.xml.rels` });
-            }
-            if (worksheet.comments.length > 0) {
-                xmlStream = new XmlStream();
-                commentsXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: `xl/comments${fileIndex}.xml` });
-                xmlStream = new XmlStream();
-                vmlNotesXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: `xl/drawings/vmlDrawing${fileIndex}.vml` });
-            }
-        });
+    async writeBuffer(options) {
+        const stream = new StreamBuf();
+        await this.write(stream, options);
+        return stream.read();
     }
+    // ===========================================================================
+    // Node.js specific: Media handling with file support
+    // ===========================================================================
     async addMedia(zip, model) {
         await Promise.all(model.media.map(async (medium) => {
             if (medium.type === "image") {
@@ -802,187 +210,5 @@ class XLSX {
             throw new Error("Unsupported media");
         }));
     }
-    addDrawings(zip, model) {
-        const drawingXform = new DrawingXform();
-        const relsXform = new RelationshipsXform();
-        model.worksheets.forEach((worksheet) => {
-            const { drawing } = worksheet;
-            if (drawing) {
-                drawingXform.prepare(drawing);
-                let xml = drawingXform.toXml(drawing);
-                zip.append(xml, { name: `xl/drawings/${drawing.name}.xml` });
-                xml = relsXform.toXml(drawing.rels);
-                zip.append(xml, { name: `xl/drawings/_rels/${drawing.name}.xml.rels` });
-            }
-        });
-    }
-    addTables(zip, model) {
-        const tableXform = new TableXform();
-        model.worksheets.forEach((worksheet) => {
-            const { tables } = worksheet;
-            tables.forEach((table) => {
-                tableXform.prepare(table, {});
-                const tableXml = tableXform.toXml(table);
-                zip.append(tableXml, { name: `xl/tables/${table.target}` });
-            });
-        });
-    }
-    addPivotTables(zip, model) {
-        if (!model.pivotTables.length) {
-            return;
-        }
-        const pivotCacheRecordsXform = new PivotCacheRecordsXform();
-        const pivotCacheDefinitionXform = new PivotCacheDefinitionXform();
-        const pivotTableXform = new PivotTableXform();
-        const relsXform = new RelationshipsXform();
-        // Generate files for each pivot table
-        model.pivotTables.forEach((pivotTable) => {
-            const n = pivotTable.tableNumber;
-            // For loaded pivot tables, use the stored cache data
-            // For new pivot tables, use the source data
-            const isLoaded = pivotTable.isLoaded;
-            if (isLoaded) {
-                // Loaded pivot table - use stored cache definition and records
-                if (pivotTable.cacheDefinition) {
-                    const xml = pivotCacheDefinitionXform.toXml(pivotTable.cacheDefinition);
-                    zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
-                }
-                if (pivotTable.cacheRecords) {
-                    const xml = pivotCacheRecordsXform.toXml(pivotTable.cacheRecords);
-                    zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
-                }
-            }
-            else {
-                // New pivot table - generate from source
-                let xml = pivotCacheRecordsXform.toXml(pivotTable);
-                zip.append(xml, { name: `xl/pivotCache/pivotCacheRecords${n}.xml` });
-                xml = pivotCacheDefinitionXform.toXml(pivotTable);
-                zip.append(xml, { name: `xl/pivotCache/pivotCacheDefinition${n}.xml` });
-            }
-            // pivot cache definition rels (same for both)
-            let xml = relsXform.toXml([
-                {
-                    Id: "rId1",
-                    Type: XLSX.RelType.PivotCacheRecords,
-                    Target: `pivotCacheRecords${n}.xml`
-                }
-            ]);
-            zip.append(xml, { name: `xl/pivotCache/_rels/pivotCacheDefinition${n}.xml.rels` });
-            // pivot table
-            xml = pivotTableXform.toXml(pivotTable);
-            zip.append(xml, { name: `xl/pivotTables/pivotTable${n}.xml` });
-            xml = relsXform.toXml([
-                {
-                    Id: "rId1",
-                    Type: XLSX.RelType.PivotCacheDefinition,
-                    Target: `../pivotCache/pivotCacheDefinition${n}.xml`
-                }
-            ]);
-            zip.append(xml, { name: `xl/pivotTables/_rels/pivotTable${n}.xml.rels` });
-        });
-    }
-    _finalize(zip) {
-        return new Promise((resolve, reject) => {
-            zip.on("finish", () => {
-                resolve(this);
-            });
-            zip.on("error", reject);
-            zip.finalize();
-        });
-    }
-    prepareModel(model, options) {
-        // ensure following properties have sane values
-        model.creator = model.creator || "ExcelTS";
-        model.lastModifiedBy = model.lastModifiedBy || "ExcelTS";
-        model.created = model.created || new Date();
-        model.modified = model.modified || new Date();
-        model.useSharedStrings =
-            options.useSharedStrings !== undefined ? options.useSharedStrings : true;
-        model.useStyles = options.useStyles !== undefined ? options.useStyles : true;
-        // Manage the shared strings
-        model.sharedStrings = new SharedStringsXform();
-        // add a style manager to handle cell formats, fonts, etc.
-        model.styles = model.useStyles ? new StylesXform(true) : new StylesXform.Mock();
-        // prepare all of the things before the render
-        const workbookXform = new WorkbookXform();
-        const worksheetXform = new WorkSheetXform();
-        workbookXform.prepare(model);
-        const worksheetOptions = {
-            sharedStrings: model.sharedStrings,
-            styles: model.styles,
-            date1904: model.properties.date1904,
-            drawingsCount: 0,
-            media: model.media
-        };
-        worksheetOptions.drawings = model.drawings = [];
-        worksheetOptions.commentRefs = model.commentRefs = [];
-        let tableCount = 0;
-        model.tables = [];
-        model.worksheets.forEach((worksheet) => {
-            // assign unique filenames to tables
-            worksheet.tables.forEach((table) => {
-                tableCount++;
-                table.target = `table${tableCount}.xml`;
-                table.id = tableCount;
-                model.tables.push(table);
-            });
-            worksheetXform.prepare(worksheet, worksheetOptions);
-        });
-        // TODO: workbook drawing list
-    }
-    async write(stream, options) {
-        options = options || {};
-        const { model } = this.workbook;
-        const zip = new ZipWriter(options.zip);
-        zip.pipe(stream);
-        this.prepareModel(model, options);
-        // render
-        await this.addContentTypes(zip, model);
-        await this.addOfficeRels(zip, model);
-        await this.addWorkbookRels(zip, model);
-        await this.addWorksheets(zip, model);
-        await this.addSharedStrings(zip, model); // always after worksheets
-        this.addDrawings(zip, model);
-        this.addTables(zip, model);
-        this.addPivotTables(zip, model);
-        await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
-        await this.addMedia(zip, model);
-        await Promise.all([this.addApp(zip, model), this.addCore(zip, model)]);
-        await this.addWorkbook(zip, model);
-        return this._finalize(zip);
-    }
-    writeFile(filename, options) {
-        const stream = fs.createWriteStream(filename);
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                stream.removeListener("finish", onFinish);
-                stream.removeListener("error", onError);
-            };
-            const onFinish = () => {
-                cleanup();
-                resolve();
-            };
-            const onError = (error) => {
-                cleanup();
-                reject(error);
-            };
-            stream.once("finish", onFinish);
-            stream.on("error", onError);
-            this.write(stream, options)
-                .then(() => {
-                stream.end();
-            })
-                .catch(err => {
-                cleanup();
-                reject(err);
-            });
-        });
-    }
-    async writeBuffer(options) {
-        const stream = new StreamBuf();
-        await this.write(stream, options);
-        return stream.read();
-    }
 }
-XLSX.RelType = RelType;
 export { XLSX };