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

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

@@ -1,1155 +0,0 @@
-"use strict";
-/**
- * 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XLSX = void 0;
-const xml_stream_1 = require("@excel/utils/xml-stream");
-const styles_xform_1 = require("@excel/xlsx/xform/style/styles-xform");
-const core_xform_1 = require("@excel/xlsx/xform/core/core-xform");
-const shared_strings_xform_1 = require("@excel/xlsx/xform/strings/shared-strings-xform");
-const relationships_xform_1 = require("@excel/xlsx/xform/core/relationships-xform");
-const content_types_xform_1 = require("@excel/xlsx/xform/core/content-types-xform");
-const app_xform_1 = require("@excel/xlsx/xform/core/app-xform");
-const workbook_xform_1 = require("@excel/xlsx/xform/book/workbook-xform");
-const worksheet_xform_1 = require("@excel/xlsx/xform/sheet/worksheet-xform");
-const drawing_xform_1 = require("@excel/xlsx/xform/drawing/drawing-xform");
-const table_xform_1 = require("@excel/xlsx/xform/table/table-xform");
-const pivot_cache_records_xform_1 = require("@excel/xlsx/xform/pivot-table/pivot-cache-records-xform");
-const pivot_cache_definition_xform_1 = require("@excel/xlsx/xform/pivot-table/pivot-cache-definition-xform");
-const pivot_table_xform_1 = require("@excel/xlsx/xform/pivot-table/pivot-table-xform");
-const comments_xform_1 = require("@excel/xlsx/xform/comment/comments-xform");
-const vml_notes_xform_1 = require("@excel/xlsx/xform/comment/vml-notes-xform");
-const theme1_1 = require("@excel/xlsx/xml/theme1");
-const rel_type_1 = require("@excel/xlsx/rel-type");
-const stream_buf_1 = require("@excel/utils/stream-buf");
-const utils_1 = require("@utils/utils");
-const streaming_zip_1 = require("@archive/streaming-zip");
-const _archive_1 = require("@archive");
-const _stream_1 = require("@stream");
-const ooxml_paths_1 = require("@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 streaming_zip_1.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 = (0, utils_1.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 streaming_zip_1.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 _stream_1.PassThrough();
-        stream.end(data);
-        return stream;
-    }
-    /**
-     * Create a stream from string content (for XML parsing)
-     */
-    createTextStream(content) {
-        const stream = new _stream_1.PassThrough();
-        stream.end(content);
-        return stream;
-    }
-    // ===========================================================================
-    // Shared implementations - used by all platforms
-    // ===========================================================================
-    /**
-     * Create a StreamBuf instance for buffering data
-     */
-    createStreamBuf() {
-        return new stream_buf_1.StreamBuf();
-    }
-    /**
-     * Convert buffer/Uint8Array to string
-     */
-    bufferToString(data) {
-        return (0, utils_1.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((0, _stream_1.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 = (0, utils_1.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 _archive_1.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 = (0, ooxml_paths_1.normalizeZipPath)(entry.name);
-            const stream = entry.stream;
-            try {
-                const sheetNo = (0, ooxml_paths_1.getWorksheetNoFromWorksheetPath)(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                    continue;
-                }
-                switch (entryName) {
-                    case ooxml_paths_1.OOXML_PATHS.rootRels:
-                        model.globalRels = await this.parseRels(stream);
-                        break;
-                    case ooxml_paths_1.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_1.OOXML_PATHS.xlSharedStrings:
-                        model.sharedStrings = new shared_strings_xform_1.SharedStringsXform();
-                        await model.sharedStrings.parseStream(stream);
-                        break;
-                    case ooxml_paths_1.OOXML_PATHS.xlWorkbookRels:
-                        model.workbookRels = await this.parseRels(stream);
-                        break;
-                    case ooxml_paths_1.OOXML_PATHS.docPropsApp: {
-                        const appXform = new app_xform_1.AppXform();
-                        const appProperties = await appXform.parseStream(stream);
-                        model.company = appProperties.company;
-                        model.manager = appProperties.manager;
-                        break;
-                    }
-                    case ooxml_paths_1.OOXML_PATHS.docPropsCore: {
-                        const coreXform = new core_xform_1.CoreXform();
-                        const coreProperties = await coreXform.parseStream(stream);
-                        Object.assign(model, coreProperties);
-                        break;
-                    }
-                    case ooxml_paths_1.OOXML_PATHS.xlStyles:
-                        model.styles = new styles_xform_1.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 = (0, ooxml_paths_1.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 relationships_xform_1.RelationshipsXform();
-        return xform.parseStream(stream);
-    }
-    parseWorkbook(stream) {
-        const xform = new workbook_xform_1.WorkbookXform();
-        return xform.parseStream(stream);
-    }
-    parseSharedStrings(stream) {
-        const xform = new shared_strings_xform_1.SharedStringsXform();
-        return xform.parseStream(stream);
-    }
-    // ===========================================================================
-    // Reconcile - shared by all platforms
-    // ===========================================================================
-    reconcile(model, options) {
-        const workbookXform = new workbook_xform_1.WorkbookXform();
-        const worksheetXform = new worksheet_xform_1.WorkSheetXform(options);
-        const drawingXform = new drawing_xform_1.DrawingXform();
-        const tableXform = new table_xform_1.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[(0, ooxml_paths_1.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 worksheet_xform_1.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 comments_xform_1.CommentsXform();
-        const comments = await xform.parseStream(stream);
-        model.comments[(0, ooxml_paths_1.commentsRelTargetFromWorksheetName)(name)] = comments;
-    }
-    async _processTableEntry(stream, model, name) {
-        const xform = new table_xform_1.TableXform();
-        const table = await xform.parseStream(stream);
-        model.tables[(0, ooxml_paths_1.tableRelTargetFromWorksheetName)(name)] = table;
-    }
-    async _processWorksheetRelsEntry(stream, model, sheetNo) {
-        const xform = new relationships_xform_1.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 drawing_xform_1.DrawingXform();
-        const drawing = await xform.parseStream(entry);
-        model.drawings[name] = drawing;
-    }
-    async _processDrawingRelsEntry(entry, model, name) {
-        const xform = new relationships_xform_1.RelationshipsXform();
-        const relationships = await xform.parseStream(entry);
-        model.drawingRels[name] = relationships;
-    }
-    async _processVmlDrawingEntry(entry, model, name) {
-        const xform = new vml_notes_xform_1.VmlNotesXform();
-        const vmlDrawing = await xform.parseStream(entry);
-        model.vmlDrawings[(0, ooxml_paths_1.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 pivot_table_xform_1.PivotTableXform();
-        const pivotTable = await xform.parseStream(stream);
-        if (pivotTable) {
-            model.pivotTables[name] = pivotTable;
-        }
-    }
-    async _processPivotTableRelsEntry(stream, model, name) {
-        const xform = new relationships_xform_1.RelationshipsXform();
-        const relationships = await xform.parseStream(stream);
-        model.pivotTableRels[name] = relationships;
-    }
-    async _processPivotCacheDefinitionEntry(stream, model, name) {
-        const xform = new pivot_cache_definition_xform_1.PivotCacheDefinitionXform();
-        const cacheDefinition = await xform.parseStream(stream);
-        if (cacheDefinition) {
-            model.pivotCacheDefinitions[name] = cacheDefinition;
-        }
-    }
-    async _processPivotCacheDefinitionRelsEntry(stream, model, name) {
-        const xform = new relationships_xform_1.RelationshipsXform();
-        const relationships = await xform.parseStream(stream);
-        model.pivotCacheDefinitionRels[name] = relationships;
-    }
-    async _processPivotCacheRecordsEntry(stream, model, name) {
-        const xform = new pivot_cache_records_xform_1.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 = (0, ooxml_paths_1.normalizeZipPath)(entry.name);
-                // Create appropriate stream based on entry type
-                const isBinaryEntry = (0, ooxml_paths_1.isBinaryEntryPath)(entryName);
-                const stream = isBinaryEntry
-                    ? this.createBinaryStream(entry.data)
-                    : this.createTextStream(this.bufferToString(entry.data));
-                const sheetNo = (0, ooxml_paths_1.getWorksheetNoFromWorksheetPath)(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                }
-                else {
-                    switch (entryName) {
-                        case ooxml_paths_1.OOXML_PATHS.rootRels:
-                            model.globalRels = await this.parseRels(stream);
-                            break;
-                        case ooxml_paths_1.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_1.OOXML_PATHS.xlSharedStrings:
-                            model.sharedStrings = new shared_strings_xform_1.SharedStringsXform();
-                            await model.sharedStrings.parseStream(stream);
-                            break;
-                        case ooxml_paths_1.OOXML_PATHS.xlWorkbookRels:
-                            model.workbookRels = await this.parseRels(stream);
-                            break;
-                        case ooxml_paths_1.OOXML_PATHS.docPropsApp: {
-                            const appXform = new app_xform_1.AppXform();
-                            const appProperties = await appXform.parseStream(stream);
-                            model.company = appProperties.company;
-                            model.manager = appProperties.manager;
-                            break;
-                        }
-                        case ooxml_paths_1.OOXML_PATHS.docPropsCore: {
-                            const coreXform = new core_xform_1.CoreXform();
-                            const coreProperties = await coreXform.parseStream(stream);
-                            Object.assign(model, coreProperties);
-                            break;
-                        }
-                        case ooxml_paths_1.OOXML_PATHS.xlStyles:
-                            model.styles = new styles_xform_1.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 = (0, ooxml_paths_1.getWorksheetNoFromWorksheetRelsPath)(entryName);
-        if (worksheetRelsSheetNo !== undefined) {
-            const sheetNo = worksheetRelsSheetNo;
-            await this._processWorksheetRelsEntry(stream, model, sheetNo);
-            return true;
-        }
-        const mediaFilename = (0, ooxml_paths_1.getMediaFilenameFromPath)(entryName);
-        if (mediaFilename) {
-            await this._processMediaEntry(stream, model, mediaFilename);
-            return true;
-        }
-        const drawingName = (0, ooxml_paths_1.getDrawingNameFromPath)(entryName);
-        if (drawingName) {
-            await this._processDrawingEntry(stream, model, drawingName);
-            return true;
-        }
-        const drawingRelsName = (0, ooxml_paths_1.getDrawingNameFromRelsPath)(entryName);
-        if (drawingRelsName) {
-            await this._processDrawingRelsEntry(stream, model, drawingRelsName);
-            return true;
-        }
-        const vmlDrawingName = (0, ooxml_paths_1.getVmlDrawingNameFromPath)(entryName);
-        if (vmlDrawingName) {
-            await this._processVmlDrawingEntry(stream, model, vmlDrawingName);
-            return true;
-        }
-        const commentsIndex = (0, ooxml_paths_1.getCommentsIndexFromPath)(entryName);
-        if (commentsIndex) {
-            await this._processCommentEntry(stream, model, `comments${commentsIndex}`);
-            return true;
-        }
-        const tableName = (0, ooxml_paths_1.getTableNameFromPath)(entryName);
-        if (tableName) {
-            await this._processTableEntry(stream, model, tableName);
-            return true;
-        }
-        const themeName = (0, ooxml_paths_1.getThemeNameFromPath)(entryName);
-        if (themeName) {
-            await this._processThemeEntry(stream, model, themeName);
-            return true;
-        }
-        // Pivot table files
-        const pivotTableName = (0, ooxml_paths_1.getPivotTableNameFromPath)(entryName);
-        if (pivotTableName) {
-            await this._processPivotTableEntry(stream, model, pivotTableName);
-            return true;
-        }
-        const pivotTableRelsName = (0, ooxml_paths_1.getPivotTableNameFromRelsPath)(entryName);
-        if (pivotTableRelsName) {
-            await this._processPivotTableRelsEntry(stream, model, pivotTableRelsName);
-            return true;
-        }
-        // Pivot cache files
-        const pivotCacheDefinitionName = (0, ooxml_paths_1.getPivotCacheDefinitionNameFromPath)(entryName);
-        if (pivotCacheDefinitionName) {
-            await this._processPivotCacheDefinitionEntry(stream, model, pivotCacheDefinitionName);
-            return true;
-        }
-        const pivotCacheDefinitionRelsName = (0, ooxml_paths_1.getPivotCacheDefinitionNameFromRelsPath)(entryName);
-        if (pivotCacheDefinitionRelsName) {
-            await this._processPivotCacheDefinitionRelsEntry(stream, model, pivotCacheDefinitionRelsName);
-            return true;
-        }
-        const pivotCacheRecordsName = (0, ooxml_paths_1.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 content_types_xform_1.ContentTypesXform();
-        const xml = xform.toXml(model);
-        zip.append(xml, { name: ooxml_paths_1.OOXML_PATHS.contentTypes });
-    }
-    async addApp(zip, model) {
-        const xform = new app_xform_1.AppXform();
-        const xml = xform.toXml(model);
-        zip.append(xml, { name: ooxml_paths_1.OOXML_PATHS.docPropsApp });
-    }
-    async addCore(zip, model) {
-        const xform = new core_xform_1.CoreXform();
-        zip.append(xform.toXml(model), { name: ooxml_paths_1.OOXML_PATHS.docPropsCore });
-    }
-    async addThemes(zip, model) {
-        const themes = model.themes || { theme1: theme1_1.theme1Xml };
-        Object.keys(themes).forEach(name => {
-            const xml = themes[name];
-            zip.append(xml, { name: (0, ooxml_paths_1.themePath)(name) });
-        });
-    }
-    async addOfficeRels(zip, _model) {
-        const xform = new relationships_xform_1.RelationshipsXform();
-        const xml = xform.toXml([
-            { Id: "rId1", Type: XLSX.RelType.OfficeDocument, Target: ooxml_paths_1.OOXML_PATHS.xlWorkbook },
-            { Id: "rId2", Type: XLSX.RelType.CoreProperties, Target: ooxml_paths_1.OOXML_PATHS.docPropsCore },
-            { Id: "rId3", Type: XLSX.RelType.ExtenderProperties, Target: ooxml_paths_1.OOXML_PATHS.docPropsApp }
-        ]);
-        zip.append(xml, { name: ooxml_paths_1.OOXML_PATHS.rootRels });
-    }
-    async addWorkbookRels(zip, model) {
-        let count = 1;
-        const relationships = [
-            { Id: `rId${count++}`, Type: XLSX.RelType.Styles, Target: ooxml_paths_1.OOXML_REL_TARGETS.workbookStyles },
-            { Id: `rId${count++}`, Type: XLSX.RelType.Theme, Target: ooxml_paths_1.OOXML_REL_TARGETS.workbookTheme1 }
-        ];
-        if (model.sharedStrings.count) {
-            relationships.push({
-                Id: `rId${count++}`,
-                Type: XLSX.RelType.SharedStrings,
-                Target: ooxml_paths_1.OOXML_REL_TARGETS.workbookSharedStrings
-            });
-        }
-        (model.pivotTables || []).forEach((pivotTable) => {
-            pivotTable.rId = `rId${count++}`;
-            relationships.push({
-                Id: pivotTable.rId,
-                Type: XLSX.RelType.PivotCacheDefinition,
-                Target: (0, ooxml_paths_1.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 relationships_xform_1.RelationshipsXform();
-        const xml = xform.toXml(relationships);
-        zip.append(xml, { name: ooxml_paths_1.OOXML_PATHS.xlWorkbookRels });
-    }
-    async addSharedStrings(zip, model) {
-        if (model.sharedStrings && model.sharedStrings.count) {
-            zip.append(model.sharedStrings.xml, { name: ooxml_paths_1.OOXML_PATHS.xlSharedStrings });
-        }
-    }
-    async addStyles(zip, model) {
-        const { xml } = model.styles;
-        if (xml) {
-            zip.append(xml, { name: ooxml_paths_1.OOXML_PATHS.xlStyles });
-        }
-    }
-    async addWorkbook(zip, model) {
-        const xform = new workbook_xform_1.WorkbookXform();
-        zip.append(xform.toXml(model), { name: ooxml_paths_1.OOXML_PATHS.xlWorkbook });
-    }
-    async addWorksheets(zip, model) {
-        const worksheetXform = new worksheet_xform_1.WorkSheetXform();
-        const relationshipsXform = new relationships_xform_1.RelationshipsXform();
-        const commentsXform = new comments_xform_1.CommentsXform();
-        const vmlNotesXform = new vml_notes_xform_1.VmlNotesXform();
-        model.worksheets.forEach((worksheet, index) => {
-            const fileIndex = worksheet.fileIndex || index + 1;
-            let xmlStream = new xml_stream_1.XmlStream();
-            worksheetXform.render(xmlStream, worksheet);
-            zip.append(xmlStream.xml, { name: (0, ooxml_paths_1.worksheetPath)(fileIndex) });
-            if (worksheet.rels && worksheet.rels.length) {
-                xmlStream = new xml_stream_1.XmlStream();
-                relationshipsXform.render(xmlStream, worksheet.rels);
-                zip.append(xmlStream.xml, { name: (0, ooxml_paths_1.worksheetRelsPath)(fileIndex) });
-            }
-            if (worksheet.comments.length > 0) {
-                xmlStream = new xml_stream_1.XmlStream();
-                commentsXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: (0, ooxml_paths_1.commentsPath)(fileIndex) });
-                xmlStream = new xml_stream_1.XmlStream();
-                vmlNotesXform.render(xmlStream, worksheet);
-                zip.append(xmlStream.xml, { name: (0, ooxml_paths_1.vmlDrawingPath)(fileIndex) });
-            }
-        });
-    }
-    addDrawings(zip, model) {
-        const drawingXform = new drawing_xform_1.DrawingXform();
-        const relsXform = new relationships_xform_1.RelationshipsXform();
-        model.worksheets.forEach((worksheet) => {
-            const { drawing } = worksheet;
-            if (drawing) {
-                drawingXform.prepare(drawing);
-                let xml = drawingXform.toXml(drawing);
-                zip.append(xml, { name: (0, ooxml_paths_1.drawingPath)(drawing.name) });
-                xml = relsXform.toXml(drawing.rels);
-                zip.append(xml, { name: (0, ooxml_paths_1.drawingRelsPath)(drawing.name) });
-            }
-        });
-    }
-    addTables(zip, model) {
-        const tableXform = new table_xform_1.TableXform();
-        model.worksheets.forEach((worksheet) => {
-            const { tables } = worksheet;
-            tables.forEach((table) => {
-                tableXform.prepare(table, {});
-                const tableXml = tableXform.toXml(table);
-                zip.append(tableXml, { name: (0, ooxml_paths_1.tablePath)(table.target) });
-            });
-        });
-    }
-    addPivotTables(zip, model) {
-        if (!model.pivotTables.length) {
-            return;
-        }
-        const pivotCacheRecordsXform = new pivot_cache_records_xform_1.PivotCacheRecordsXform();
-        const pivotCacheDefinitionXform = new pivot_cache_definition_xform_1.PivotCacheDefinitionXform();
-        const pivotTableXform = new pivot_table_xform_1.PivotTableXform();
-        const relsXform = new relationships_xform_1.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: (0, ooxml_paths_1.pivotCacheDefinitionPath)(n) });
-                }
-                if (pivotTable.cacheRecords) {
-                    const xml = pivotCacheRecordsXform.toXml(pivotTable.cacheRecords);
-                    zip.append(xml, { name: (0, ooxml_paths_1.pivotCacheRecordsPath)(n) });
-                }
-            }
-            else {
-                let xml = pivotCacheRecordsXform.toXml(pivotTable);
-                zip.append(xml, { name: (0, ooxml_paths_1.pivotCacheRecordsPath)(n) });
-                xml = pivotCacheDefinitionXform.toXml(pivotTable);
-                zip.append(xml, { name: (0, ooxml_paths_1.pivotCacheDefinitionPath)(n) });
-            }
-            let xml = relsXform.toXml([
-                {
-                    Id: "rId1",
-                    Type: XLSX.RelType.PivotCacheRecords,
-                    Target: (0, ooxml_paths_1.pivotCacheRecordsRelTarget)(n)
-                }
-            ]);
-            zip.append(xml, { name: (0, ooxml_paths_1.pivotCacheDefinitionRelsPath)(n) });
-            xml = pivotTableXform.toXml(pivotTable);
-            zip.append(xml, { name: (0, ooxml_paths_1.pivotTablePath)(n) });
-            xml = relsXform.toXml([
-                {
-                    Id: "rId1",
-                    Type: XLSX.RelType.PivotCacheDefinition,
-                    Target: (0, ooxml_paths_1.pivotCacheDefinitionRelTargetFromPivotTable)(n)
-                }
-            ]);
-            zip.append(xml, { name: (0, ooxml_paths_1.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 shared_strings_xform_1.SharedStringsXform();
-        model.styles = model.useStyles ? new styles_xform_1.StylesXform(true) : new styles_xform_1.StylesXform.Mock();
-        const workbookXform = new workbook_xform_1.WorkbookXform();
-        const worksheetXform = new worksheet_xform_1.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);
-        });
-    }
-}
-exports.XLSX = XLSX;
-XLSX.RelType = rel_type_1.RelType;