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

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

@@ -1,1152 +0,0 @@
-/**
- * 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 };