@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102041828.82ed571

package/dist/esm/modules/excel/xlsx/xlsx.browser.js

@@ -0,0 +1,1152 @@
+/**
+ * XLSX - Abstract base class for XLSX operations
+ *
+ * Contains all platform-agnostic logic shared between Node.js and Browser versions:
+ * - reconcile: Reconcile model after parsing
+ * - _process*Entry: Process individual ZIP entries
+ * - add*: Add content to ZIP during writing
+ * - prepareModel: Prepare model for writing
+ * - loadFromFiles: Load from pre-extracted ZIP data
+ */
+import { XmlStream } from "@excel/utils/xml-stream";
+import { StylesXform } from "@excel/xlsx/xform/style/styles-xform";
+import { CoreXform } from "@excel/xlsx/xform/core/core-xform";
+import { SharedStringsXform } from "@excel/xlsx/xform/strings/shared-strings-xform";
+import { RelationshipsXform } from "@excel/xlsx/xform/core/relationships-xform";
+import { ContentTypesXform } from "@excel/xlsx/xform/core/content-types-xform";
+import { AppXform } from "@excel/xlsx/xform/core/app-xform";
+import { WorkbookXform } from "@excel/xlsx/xform/book/workbook-xform";
+import { WorkSheetXform } from "@excel/xlsx/xform/sheet/worksheet-xform";
+import { DrawingXform } from "@excel/xlsx/xform/drawing/drawing-xform";
+import { TableXform } from "@excel/xlsx/xform/table/table-xform";
+import { PivotCacheRecordsXform } from "@excel/xlsx/xform/pivot-table/pivot-cache-records-xform";
+import { PivotCacheDefinitionXform } from "@excel/xlsx/xform/pivot-table/pivot-cache-definition-xform";
+import { PivotTableXform } from "@excel/xlsx/xform/pivot-table/pivot-table-xform";
+import { CommentsXform } from "@excel/xlsx/xform/comment/comments-xform";
+import { VmlNotesXform } from "@excel/xlsx/xform/comment/vml-notes-xform";
+import { theme1Xml } from "@excel/xlsx/xml/theme1";
+import { RelType } from "@excel/xlsx/rel-type";
+import { StreamBuf } from "@excel/utils/stream-buf";
+import { bufferToString, base64ToUint8Array } from "@utils/utils";
+import { StreamingZip, ZipDeflateFile } from "@archive/streaming-zip";
+import { ZipParser } from "@archive";
+import { PassThrough, concatUint8Arrays } from "@stream";
+import { commentsPath, commentsRelTargetFromWorksheetName, drawingPath, drawingRelsPath, OOXML_REL_TARGETS, pivotTableRelTargetFromWorksheetName, pivotCacheDefinitionRelTargetFromWorkbook, getCommentsIndexFromPath, getDrawingNameFromPath, getDrawingNameFromRelsPath, getMediaFilenameFromPath, mediaPath, getPivotCacheDefinitionNameFromPath, getPivotCacheDefinitionNameFromRelsPath, getPivotCacheRecordsNameFromPath, getPivotTableNameFromPath, getPivotTableNameFromRelsPath, pivotCacheDefinitionPath, pivotCacheDefinitionRelsPath, pivotCacheDefinitionRelTargetFromPivotTable, pivotCacheRecordsPath, pivotCacheRecordsRelTarget, pivotTablePath, pivotTableRelsPath, getTableNameFromPath, tablePath, tableRelTargetFromWorksheetName, themePath, getThemeNameFromPath, getVmlDrawingNameFromPath, getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, isBinaryEntryPath, normalizeZipPath, OOXML_PATHS, vmlDrawingRelTargetFromWorksheetName, vmlDrawingPath, worksheetPath, worksheetRelsPath } from "@excel/utils/ooxml-paths";
+class StreamingZipWriterAdapter {
+    constructor(options) {
+        this.events = new Map();
+        this.pipedStream = null;
+        this.finalized = false;
+        this.level = options?.level ?? 6;
+        this.modTime = options?.modTime;
+        this.timestamps = options?.timestamps;
+        this.zip = new StreamingZip((err, data, final) => {
+            if (err) {
+                this._emit("error", err);
+                return;
+            }
+            if (data && data.length > 0) {
+                this._emit("data", data);
+                if (this.pipedStream) {
+                    this.pipedStream.write(data);
+                }
+            }
+            if (final) {
+                if (this.pipedStream) {
+                    this.pipedStream.end();
+                }
+                this._emit("finish");
+            }
+        });
+    }
+    _emit(event, ...args) {
+        const callbacks = this.events.get(event);
+        if (!callbacks) {
+            return;
+        }
+        for (const cb of callbacks) {
+            cb(...args);
+        }
+    }
+    on(event, callback) {
+        const callbacks = this.events.get(event) || new Set();
+        callbacks.add(callback);
+        this.events.set(event, callbacks);
+        return this;
+    }
+    once(event, callback) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            callback(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, callback) {
+        const callbacks = this.events.get(event);
+        if (!callbacks) {
+            return this;
+        }
+        callbacks.delete(callback);
+        if (callbacks.size === 0) {
+            this.events.delete(event);
+        }
+        return this;
+    }
+    pipe(stream) {
+        this.pipedStream = stream;
+    }
+    append(data, options) {
+        if (this.finalized) {
+            throw new Error("Cannot append after finalize");
+        }
+        let buffer;
+        if (options.base64) {
+            buffer = base64ToUint8Array(typeof data === "string" ? data : String(data));
+        }
+        else if (typeof data === "string") {
+            buffer = StreamingZipWriterAdapter.textEncoder.encode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            buffer = new Uint8Array(data);
+        }
+        else {
+            buffer = data;
+        }
+        const file = new ZipDeflateFile(options.name, {
+            level: this.level,
+            modTime: this.modTime,
+            timestamps: this.timestamps
+        });
+        this.zip.add(file);
+        const pushResult = file.push(buffer, true);
+        if (pushResult && typeof pushResult.catch === "function") {
+            pushResult.catch((err) => this._emit("error", err));
+        }
+    }
+    finalize() {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        this.zip.end();
+    }
+}
+StreamingZipWriterAdapter.textEncoder = new TextEncoder();
+/**
+ * XLSX class - handles Excel file operations
+ * Works in both Node.js and Browser environments
+ */
+class XLSX {
+    constructor(workbook) {
+        this.workbook = workbook;
+    }
+    // ===========================================================================
+    // Stream creation - cross-platform implementation using modules/stream
+    // ===========================================================================
+    /**
+     * Create a stream from binary data (for media/themes)
+     */
+    createBinaryStream(data) {
+        const stream = new PassThrough();
+        stream.end(data);
+        return stream;
+    }
+    /**
+     * Create a stream from string content (for XML parsing)
+     */
+    createTextStream(content) {
+        const stream = new PassThrough();
+        stream.end(content);
+        return stream;
+    }
+    // ===========================================================================
+    // Shared implementations - used by all platforms
+    // ===========================================================================
+    /**
+     * Create a StreamBuf instance for buffering data
+     */
+    createStreamBuf() {
+        return new StreamBuf();
+    }
+    /**
+     * Convert buffer/Uint8Array to string
+     */
+    bufferToString(data) {
+        return bufferToString(data);
+    }
+    /**
+     * Create a ZIP writer adapter.
+     * Can be overridden by subclasses for platform-specific implementations.
+     */
+    createZipWriter(options) {
+        return new StreamingZipWriterAdapter(options);
+    }
+    /**
+     * Write all workbook content to a ZIP writer
+     * Shared by both Node.js write() and browser writeBuffer()
+     */
+    async writeToZip(zip, options) {
+        const { model } = this.workbook;
+        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);
+    }
+    // ===========================================================================
+    // Stream/Buffer operations - shared by all platforms
+    // ===========================================================================
+    /**
+     * Read workbook from a stream
+     */
+    async read(stream, options) {
+        // Collect all stream data into a single buffer
+        const chunks = [];
+        await new Promise((resolve, reject) => {
+            const onData = (chunk) => {
+                chunks.push(chunk);
+            };
+            const onEnd = () => {
+                stream.off("data", onData);
+                stream.off("end", onEnd);
+                stream.off("error", onError);
+                resolve();
+            };
+            const onError = (err) => {
+                stream.off("data", onData);
+                stream.off("end", onEnd);
+                stream.off("error", onError);
+                reject(err);
+            };
+            stream.on("data", onData);
+            stream.on("end", onEnd);
+            stream.on("error", onError);
+        });
+        return this.loadBuffer(concatUint8Arrays(chunks), options);
+    }
+    /**
+     * Write workbook to a stream
+     */
+    async write(stream, options) {
+        var _a;
+        options = options || {};
+        options.zip = options.zip || {};
+        (_a = options.zip).modTime ?? (_a.modTime = this.workbook.modified ?? this.workbook.created);
+        const zip = this.createZipWriter(options.zip);
+        zip.pipe(stream);
+        await this.writeToZip(zip, options);
+        return this._finalize(zip);
+    }
+    /**
+     * Load workbook from buffer/ArrayBuffer/Uint8Array
+     */
+    async load(data, options) {
+        let buffer;
+        // Validate input
+        const isBuffer = typeof Buffer !== "undefined" ? Buffer.isBuffer(data) : false;
+        if (!data ||
+            (typeof data === "object" &&
+                !isBuffer &&
+                !(data instanceof Uint8Array) &&
+                !(data instanceof ArrayBuffer))) {
+            throw new Error("Can't read the data of 'the loaded zip file'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?");
+        }
+        // Handle base64 input
+        if (options && options.base64) {
+            buffer = base64ToUint8Array(data.toString());
+        }
+        else if (data instanceof ArrayBuffer) {
+            buffer = new Uint8Array(data);
+        }
+        else if (data instanceof Uint8Array) {
+            buffer = data;
+        }
+        else {
+            // Node.js Buffer or other array-like
+            buffer = new Uint8Array(data);
+        }
+        return this.loadBuffer(buffer, options);
+    }
+    /**
+     * Internal: Load from Uint8Array buffer
+     */
+    async loadBuffer(buffer, options) {
+        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);
+    }
+    /**
+     * Internal: Load workbook from an async stream of ZIP entries.
+     *
+     * This is the foundation for TRUE streaming reads on platforms that have a
+     * streaming ZIP parser (e.g. Node.js `modules/archive` Parse).
+     */
+    async loadFromZipEntries(entries, options) {
+        const model = {
+            worksheets: [],
+            worksheetHash: {},
+            worksheetRels: [],
+            themes: {},
+            media: [],
+            mediaIndex: {},
+            drawings: {},
+            drawingRels: {},
+            comments: {},
+            tables: {},
+            vmlDrawings: {},
+            pivotTables: {},
+            pivotTableRels: {},
+            pivotCacheDefinitions: {},
+            pivotCacheDefinitionRels: {},
+            pivotCacheRecords: {}
+        };
+        for await (const entry of entries) {
+            let drained = false;
+            const drainEntry = async () => {
+                if (drained) {
+                    return;
+                }
+                drained = true;
+                await entry.drain();
+            };
+            if (entry.type === "Directory") {
+                await drainEntry();
+                continue;
+            }
+            const entryName = normalizeZipPath(entry.name);
+            const stream = entry.stream;
+            try {
+                const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
+                if (sheetNo !== undefined) {
+                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
+                    continue;
+                }
+                switch (entryName) {
+                    case OOXML_PATHS.rootRels:
+                        model.globalRels = await this.parseRels(stream);
+                        break;
+                    case OOXML_PATHS.xlWorkbook: {
+                        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;
+                        model.pivotCaches = workbook.pivotCaches;
+                        break;
+                    }
+                    case OOXML_PATHS.xlSharedStrings:
+                        model.sharedStrings = new SharedStringsXform();
+                        await model.sharedStrings.parseStream(stream);
+                        break;
+                    case OOXML_PATHS.xlWorkbookRels:
+                        model.workbookRels = await this.parseRels(stream);
+                        break;
+                    case OOXML_PATHS.docPropsApp: {
+                        const appXform = new AppXform();
+                        const appProperties = await appXform.parseStream(stream);
+                        model.company = appProperties.company;
+                        model.manager = appProperties.manager;
+                        break;
+                    }
+                    case OOXML_PATHS.docPropsCore: {
+                        const coreXform = new CoreXform();
+                        const coreProperties = await coreXform.parseStream(stream);
+                        Object.assign(model, coreProperties);
+                        break;
+                    }
+                    case OOXML_PATHS.xlStyles:
+                        model.styles = new StylesXform();
+                        await model.styles.parseStream(stream);
+                        break;
+                    default: {
+                        const handled = await this._processDefaultEntry(stream, model, entryName);
+                        if (!handled) {
+                            // Important for true streaming parsers: always consume unknown entries
+                            await drainEntry();
+                        }
+                        break;
+                    }
+                }
+            }
+            finally {
+                // Make sure we don't leave the entry stream partially consumed.
+                // This is critical for true streaming parsers which may otherwise abort
+                // the underlying entry stream (showing up as AbortError/ABORT_ERR).
+                try {
+                    await drainEntry();
+                }
+                catch {
+                    // ignore drain errors; the primary parse error (if any) is more useful
+                }
+            }
+        }
+        this.reconcile(model, options);
+        this.workbook.model = model;
+        return this.workbook;
+    }
+    /**
+     * Write workbook to buffer
+     */
+    async writeBuffer(options) {
+        var _a;
+        options = options || {};
+        options.zip = options.zip || {};
+        (_a = options.zip).modTime ?? (_a.modTime = this.workbook.modified ?? this.workbook.created);
+        const zip = this.createZipWriter(options.zip);
+        const stream = this.createStreamBuf();
+        zip.pipe(stream);
+        await this.writeToZip(zip, options);
+        await this._finalize(zip);
+        return stream.read() || new Uint8Array(0);
+    }
+    // ===========================================================================
+    // Media handling - base implementation (buffer/base64 only)
+    // ===========================================================================
+    /**
+     * Add media files to ZIP
+     * Supports buffer, base64, and filename (if readFileAsync is provided)
+     */
+    async addMedia(zip, model) {
+        await Promise.all(model.media.map(async (medium) => {
+            if (medium.type !== "image") {
+                throw new Error("Unsupported media");
+            }
+            // Preserve legacy behavior: `${undefined}` becomes "undefined" in template strings
+            const mediaName = medium.name ?? "undefined";
+            const filename = mediaPath(`${mediaName}.${medium.extension}`);
+            if (medium.filename) {
+                if (this.readFileAsync) {
+                    const data = await this.readFileAsync(medium.filename);
+                    return zip.append(data, { name: filename });
+                }
+                throw new Error("Loading images from filename is not supported in this environment");
+            }
+            if (medium.buffer) {
+                return zip.append(medium.buffer, { name: filename });
+            }
+            if (medium.base64) {
+                const content = medium.base64.substring(medium.base64.indexOf(",") + 1);
+                return zip.append(content, { name: filename, base64: true });
+            }
+            throw new Error("Unsupported media");
+        }));
+    }
+    // ===========================================================================
+    // Parse helpers - shared by all platforms
+    // ===========================================================================
+    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 - shared by all platforms
+    // ===========================================================================
+    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
+        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;
+        delete model.pivotTableRels;
+        delete model.pivotCacheDefinitionRels;
+    }
+    /**
+     * Reconcile pivot tables by linking them to worksheets and their cache data.
+     */
+    _reconcilePivotTables(model) {
+        const rawPivotTables = model.pivotTables || {};
+        if (typeof rawPivotTables !== "object" || Object.keys(rawPivotTables).length === 0) {
+            model.pivotTables = [];
+            model.pivotTablesIndexed = {};
+            return;
+        }
+        const definitionToCacheId = this._buildDefinitionToCacheIdMap(model);
+        const cacheMap = new Map();
+        Object.entries(model.pivotCacheDefinitions || {}).forEach(([name, definition]) => {
+            const cacheId = definitionToCacheId.get(name);
+            if (cacheId !== undefined) {
+                const recordsName = name.replace("Definition", "Records");
+                cacheMap.set(cacheId, {
+                    definition,
+                    records: model.pivotCacheRecords?.[recordsName],
+                    definitionName: name
+                });
+            }
+        });
+        const loadedPivotTables = [];
+        const pivotTablesIndexed = {};
+        Object.entries(rawPivotTables).forEach(([pivotName, pivotTable]) => {
+            const pt = pivotTable;
+            const tableNumber = this._extractTableNumber(pivotName);
+            const cacheData = cacheMap.get(pt.cacheId);
+            const completePivotTable = {
+                ...pt,
+                tableNumber,
+                cacheDefinition: cacheData?.definition,
+                cacheRecords: cacheData?.records,
+                cacheFields: cacheData?.definition?.cacheFields || [],
+                rows: pt.rowFields.filter(f => f >= 0),
+                columns: pt.colFields.filter(f => f >= 0 && f !== -2),
+                values: pt.dataFields.map(df => df.fld),
+                metric: this._determineMetric(pt.dataFields),
+                applyWidthHeightFormats: pt.applyWidthHeightFormats || "0"
+            };
+            loadedPivotTables.push(completePivotTable);
+            pivotTablesIndexed[pivotTableRelTargetFromWorksheetName(pivotName)] = completePivotTable;
+        });
+        loadedPivotTables.sort((a, b) => a.tableNumber - b.tableNumber);
+        model.pivotTables = loadedPivotTables;
+        model.pivotTablesIndexed = pivotTablesIndexed;
+        model.loadedPivotTables = loadedPivotTables;
+    }
+    _extractTableNumber(name) {
+        const match = name.match(/pivotTable(\d+)/);
+        return match ? parseInt(match[1], 10) : 1;
+    }
+    _buildCacheIdMap(model) {
+        const rIdToCacheId = new Map();
+        const pivotCaches = model.pivotCaches || [];
+        for (const cache of pivotCaches) {
+            if (cache.cacheId && cache.rId) {
+                rIdToCacheId.set(cache.rId, parseInt(cache.cacheId, 10));
+            }
+        }
+        return rIdToCacheId;
+    }
+    _buildDefinitionToCacheIdMap(model) {
+        const definitionToCacheId = new Map();
+        const rIdToCacheId = this._buildCacheIdMap(model);
+        const workbookRels = model.workbookRels || [];
+        for (const rel of workbookRels) {
+            if (rel.Type === XLSX.RelType.PivotCacheDefinition && rel.Target) {
+                const match = rel.Target.match(/pivotCacheDefinition(\d+)\.xml/);
+                if (match) {
+                    const defName = `pivotCacheDefinition${match[1]}`;
+                    const cacheId = rIdToCacheId.get(rel.Id);
+                    if (cacheId !== undefined) {
+                        definitionToCacheId.set(defName, cacheId);
+                    }
+                }
+            }
+        }
+        return definitionToCacheId;
+    }
+    _determineMetric(dataFields) {
+        if (dataFields.length > 0 && dataFields[0].subtotal === "count") {
+            return "count";
+        }
+        return "sum";
+    }
+    // ===========================================================================
+    // Process Entry methods - shared by all platforms
+    // ===========================================================================
+    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[commentsRelTargetFromWorksheetName(name)] = comments;
+    }
+    async _processTableEntry(stream, model, name) {
+        const xform = new TableXform();
+        const table = await xform.parseStream(stream);
+        model.tables[tableRelTargetFromWorksheetName(name)] = 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 (lastDot >= 1) {
+            const extension = filename.substr(lastDot + 1);
+            const name = filename.substr(0, lastDot);
+            await new Promise((resolve, reject) => {
+                const streamBuf = this.createStreamBuf();
+                const cleanup = () => {
+                    stream.off("error", onError);
+                    streamBuf.off("error", onError);
+                    streamBuf.off("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.read()
+                    };
+                    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[vmlDrawingRelTargetFromWorksheetName(name)] = vmlDrawing;
+    }
+    async _processThemeEntry(stream, model, name) {
+        await new Promise((resolve, reject) => {
+            const streamBuf = this.createStreamBuf();
+            const cleanup = () => {
+                stream.off("error", onError);
+                streamBuf.off("error", onError);
+                streamBuf.off("finish", onFinish);
+            };
+            const onFinish = () => {
+                cleanup();
+                const data = streamBuf.read();
+                model.themes[name] = data
+                    ? typeof data === "string"
+                        ? data
+                        : this.bufferToString(data)
+                    : "";
+                resolve();
+            };
+            const onError = (err) => {
+                cleanup();
+                reject(err);
+            };
+            streamBuf.once("finish", onFinish);
+            stream.on("error", onError);
+            streamBuf.on("error", onError);
+            stream.pipe(streamBuf);
+        });
+    }
+    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;
+        }
+    }
+    // ===========================================================================
+    // loadFromFiles - shared logic for loading from pre-extracted ZIP data
+    // ===========================================================================
+    async loadFromFiles(zipData, options) {
+        const model = {
+            worksheets: [],
+            worksheetHash: {},
+            worksheetRels: [],
+            themes: {},
+            media: [],
+            mediaIndex: {},
+            drawings: {},
+            drawingRels: {},
+            comments: {},
+            tables: {},
+            vmlDrawings: {},
+            pivotTables: {},
+            pivotTableRels: {},
+            pivotCacheDefinitions: {},
+            pivotCacheDefinitionRels: {},
+            pivotCacheRecords: {}
+        };
+        const entries = Object.keys(zipData).map(name => ({
+            name,
+            dir: name.endsWith("/"),
+            data: zipData[name]
+        }));
+        for (const entry of entries) {
+            if (!entry.dir) {
+                const entryName = normalizeZipPath(entry.name);
+                // Create appropriate stream based on entry type
+                const isBinaryEntry = isBinaryEntryPath(entryName);
+                const stream = isBinaryEntry
+                    ? this.createBinaryStream(entry.data)
+                    : this.createTextStream(this.bufferToString(entry.data));
+                const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
+                if (sheetNo !== undefined) {
+                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
+                }
+                else {
+                    switch (entryName) {
+                        case OOXML_PATHS.rootRels:
+                            model.globalRels = await this.parseRels(stream);
+                            break;
+                        case OOXML_PATHS.xlWorkbook: {
+                            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;
+                            model.pivotCaches = workbook.pivotCaches;
+                            break;
+                        }
+                        case OOXML_PATHS.xlSharedStrings:
+                            model.sharedStrings = new SharedStringsXform();
+                            await model.sharedStrings.parseStream(stream);
+                            break;
+                        case OOXML_PATHS.xlWorkbookRels:
+                            model.workbookRels = await this.parseRels(stream);
+                            break;
+                        case OOXML_PATHS.docPropsApp: {
+                            const appXform = new AppXform();
+                            const appProperties = await appXform.parseStream(stream);
+                            model.company = appProperties.company;
+                            model.manager = appProperties.manager;
+                            break;
+                        }
+                        case OOXML_PATHS.docPropsCore: {
+                            const coreXform = new CoreXform();
+                            const coreProperties = await coreXform.parseStream(stream);
+                            Object.assign(model, coreProperties);
+                            break;
+                        }
+                        case OOXML_PATHS.xlStyles:
+                            model.styles = new StylesXform();
+                            await model.styles.parseStream(stream);
+                            break;
+                        default:
+                            await this._processDefaultEntry(stream, model, entryName);
+                    }
+                }
+            }
+        }
+        this.reconcile(model, options);
+        this.workbook.model = model;
+        return this.workbook;
+    }
+    /**
+     * Process default entries (drawings, comments, tables, etc.)
+     */
+    async _processDefaultEntry(stream, model, entryName) {
+        const worksheetRelsSheetNo = getWorksheetNoFromWorksheetRelsPath(entryName);
+        if (worksheetRelsSheetNo !== undefined) {
+            const sheetNo = worksheetRelsSheetNo;
+            await this._processWorksheetRelsEntry(stream, model, sheetNo);
+            return true;
+        }
+        const mediaFilename = getMediaFilenameFromPath(entryName);
+        if (mediaFilename) {
+            await this._processMediaEntry(stream, model, mediaFilename);
+            return true;
+        }
+        const drawingName = getDrawingNameFromPath(entryName);
+        if (drawingName) {
+            await this._processDrawingEntry(stream, model, drawingName);
+            return true;
+        }
+        const drawingRelsName = getDrawingNameFromRelsPath(entryName);
+        if (drawingRelsName) {
+            await this._processDrawingRelsEntry(stream, model, drawingRelsName);
+            return true;
+        }
+        const vmlDrawingName = getVmlDrawingNameFromPath(entryName);
+        if (vmlDrawingName) {
+            await this._processVmlDrawingEntry(stream, model, vmlDrawingName);
+            return true;
+        }
+        const commentsIndex = getCommentsIndexFromPath(entryName);
+        if (commentsIndex) {
+            await this._processCommentEntry(stream, model, `comments${commentsIndex}`);
+            return true;
+        }
+        const tableName = getTableNameFromPath(entryName);
+        if (tableName) {
+            await this._processTableEntry(stream, model, tableName);
+            return true;
+        }
+        const themeName = getThemeNameFromPath(entryName);
+        if (themeName) {
+            await this._processThemeEntry(stream, model, themeName);
+            return true;
+        }
+        // Pivot table files
+        const pivotTableName = getPivotTableNameFromPath(entryName);
+        if (pivotTableName) {
+            await this._processPivotTableEntry(stream, model, pivotTableName);
+            return true;
+        }
+        const pivotTableRelsName = getPivotTableNameFromRelsPath(entryName);
+        if (pivotTableRelsName) {
+            await this._processPivotTableRelsEntry(stream, model, pivotTableRelsName);
+            return true;
+        }
+        // Pivot cache files
+        const pivotCacheDefinitionName = getPivotCacheDefinitionNameFromPath(entryName);
+        if (pivotCacheDefinitionName) {
+            await this._processPivotCacheDefinitionEntry(stream, model, pivotCacheDefinitionName);
+            return true;
+        }
+        const pivotCacheDefinitionRelsName = getPivotCacheDefinitionNameFromRelsPath(entryName);
+        if (pivotCacheDefinitionRelsName) {
+            await this._processPivotCacheDefinitionRelsEntry(stream, model, pivotCacheDefinitionRelsName);
+            return true;
+        }
+        const pivotCacheRecordsName = getPivotCacheRecordsNameFromPath(entryName);
+        if (pivotCacheRecordsName) {
+            await this._processPivotCacheRecordsEntry(stream, model, pivotCacheRecordsName);
+            return true;
+        }
+        return false;
+    }
+    // ===========================================================================
+    // Write methods - shared by all platforms
+    // ===========================================================================
+    async addContentTypes(zip, model) {
+        const xform = new ContentTypesXform();
+        const xml = xform.toXml(model);
+        zip.append(xml, { name: OOXML_PATHS.contentTypes });
+    }
+    async addApp(zip, model) {
+        const xform = new AppXform();
+        const xml = xform.toXml(model);
+        zip.append(xml, { name: OOXML_PATHS.docPropsApp });
+    }
+    async addCore(zip, model) {
+        const xform = new CoreXform();
+        zip.append(xform.toXml(model), { name: OOXML_PATHS.docPropsCore });
+    }
+    async addThemes(zip, model) {
+        const themes = model.themes || { theme1: theme1Xml };
+        Object.keys(themes).forEach(name => {
+            const xml = themes[name];
+            zip.append(xml, { name: themePath(name) });
+        });
+    }
+    async addOfficeRels(zip, _model) {
+        const xform = new RelationshipsXform();
+        const xml = xform.toXml([
+            { Id: "rId1", Type: XLSX.RelType.OfficeDocument, Target: OOXML_PATHS.xlWorkbook },
+            { Id: "rId2", Type: XLSX.RelType.CoreProperties, Target: OOXML_PATHS.docPropsCore },
+            { Id: "rId3", Type: XLSX.RelType.ExtenderProperties, Target: OOXML_PATHS.docPropsApp }
+        ]);
+        zip.append(xml, { name: OOXML_PATHS.rootRels });
+    }
+    async addWorkbookRels(zip, model) {
+        let count = 1;
+        const relationships = [
+            { Id: `rId${count++}`, Type: XLSX.RelType.Styles, Target: OOXML_REL_TARGETS.workbookStyles },
+            { Id: `rId${count++}`, Type: XLSX.RelType.Theme, Target: OOXML_REL_TARGETS.workbookTheme1 }
+        ];
+        if (model.sharedStrings.count) {
+            relationships.push({
+                Id: `rId${count++}`,
+                Type: XLSX.RelType.SharedStrings,
+                Target: OOXML_REL_TARGETS.workbookSharedStrings
+            });
+        }
+        (model.pivotTables || []).forEach((pivotTable) => {
+            pivotTable.rId = `rId${count++}`;
+            relationships.push({
+                Id: pivotTable.rId,
+                Type: XLSX.RelType.PivotCacheDefinition,
+                Target: pivotCacheDefinitionRelTargetFromWorkbook(pivotTable.tableNumber)
+            });
+        });
+        model.worksheets.forEach((worksheet, index) => {
+            worksheet.rId = `rId${count++}`;
+            worksheet.fileIndex = index + 1;
+            relationships.push({
+                Id: worksheet.rId,
+                Type: XLSX.RelType.Worksheet,
+                Target: `worksheets/sheet${worksheet.fileIndex}.xml`
+            });
+        });
+        const xform = new RelationshipsXform();
+        const xml = xform.toXml(relationships);
+        zip.append(xml, { name: OOXML_PATHS.xlWorkbookRels });
+    }
+    async addSharedStrings(zip, model) {
+        if (model.sharedStrings && model.sharedStrings.count) {
+            zip.append(model.sharedStrings.xml, { name: OOXML_PATHS.xlSharedStrings });
+        }
+    }
+    async addStyles(zip, model) {
+        const { xml } = model.styles;
+        if (xml) {
+            zip.append(xml, { name: OOXML_PATHS.xlStyles });
+        }
+    }
+    async addWorkbook(zip, model) {
+        const xform = new WorkbookXform();
+        zip.append(xform.toXml(model), { name: OOXML_PATHS.xlWorkbook });
+    }
+    async addWorksheets(zip, model) {
+        const worksheetXform = new WorkSheetXform();
+        const relationshipsXform = new RelationshipsXform();
+        const commentsXform = new CommentsXform();
+        const vmlNotesXform = new VmlNotesXform();
+        model.worksheets.forEach((worksheet, index) => {
+            const fileIndex = worksheet.fileIndex || index + 1;
+            let xmlStream = new XmlStream();
+            worksheetXform.render(xmlStream, worksheet);
+            zip.append(xmlStream.xml, { name: worksheetPath(fileIndex) });
+            if (worksheet.rels && worksheet.rels.length) {
+                xmlStream = new XmlStream();
+                relationshipsXform.render(xmlStream, worksheet.rels);
+                zip.append(xmlStream.xml, { name: worksheetRelsPath(fileIndex) });
+            }
+            if (worksheet.comments.length > 0) {
+                xmlStream = new XmlStream();
+                commentsXform.render(xmlStream, worksheet);
+                zip.append(xmlStream.xml, { name: commentsPath(fileIndex) });
+                xmlStream = new XmlStream();
+                vmlNotesXform.render(xmlStream, worksheet);
+                zip.append(xmlStream.xml, { name: vmlDrawingPath(fileIndex) });
+            }
+        });
+    }
+    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: drawingPath(drawing.name) });
+                xml = relsXform.toXml(drawing.rels);
+                zip.append(xml, { name: drawingRelsPath(drawing.name) });
+            }
+        });
+    }
+    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: tablePath(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();
+        model.pivotTables.forEach((pivotTable) => {
+            const n = pivotTable.tableNumber;
+            const isLoaded = pivotTable.isLoaded;
+            if (isLoaded) {
+                if (pivotTable.cacheDefinition) {
+                    const xml = pivotCacheDefinitionXform.toXml(pivotTable.cacheDefinition);
+                    zip.append(xml, { name: pivotCacheDefinitionPath(n) });
+                }
+                if (pivotTable.cacheRecords) {
+                    const xml = pivotCacheRecordsXform.toXml(pivotTable.cacheRecords);
+                    zip.append(xml, { name: pivotCacheRecordsPath(n) });
+                }
+            }
+            else {
+                let xml = pivotCacheRecordsXform.toXml(pivotTable);
+                zip.append(xml, { name: pivotCacheRecordsPath(n) });
+                xml = pivotCacheDefinitionXform.toXml(pivotTable);
+                zip.append(xml, { name: pivotCacheDefinitionPath(n) });
+            }
+            let xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSX.RelType.PivotCacheRecords,
+                    Target: pivotCacheRecordsRelTarget(n)
+                }
+            ]);
+            zip.append(xml, { name: pivotCacheDefinitionRelsPath(n) });
+            xml = pivotTableXform.toXml(pivotTable);
+            zip.append(xml, { name: pivotTablePath(n) });
+            xml = relsXform.toXml([
+                {
+                    Id: "rId1",
+                    Type: XLSX.RelType.PivotCacheDefinition,
+                    Target: pivotCacheDefinitionRelTargetFromPivotTable(n)
+                }
+            ]);
+            zip.append(xml, { name: pivotTableRelsPath(n) });
+        });
+    }
+    _finalize(zip) {
+        return new Promise((resolve, reject) => {
+            zip.on("finish", () => {
+                resolve(this);
+            });
+            zip.on("error", reject);
+            zip.finalize();
+        });
+    }
+    prepareModel(model, options) {
+        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;
+        model.sharedStrings = new SharedStringsXform();
+        model.styles = model.useStyles ? new StylesXform(true) : new StylesXform.Mock();
+        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) => {
+            worksheet.tables.forEach((table) => {
+                tableCount++;
+                table.target = `table${tableCount}.xml`;
+                table.id = tableCount;
+                model.tables.push(table);
+            });
+            worksheetXform.prepare(worksheet, worksheetOptions);
+        });
+    }
+}
+XLSX.RelType = RelType;
+export { XLSX };