@cj-tech-master/excelts 4.2.3-canary.20260115111903.b80904d → 4.2.3-canary.20260122073152.a9bb6b0

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

@@ -34,6 +34,7 @@ import { StreamingZip, ZipDeflateFile } from "../../archive/zip/stream.js";
 import { ZipParser } from "../../archive/unzip/zip-parser.js";
 import { PassThrough, concatUint8Arrays } from "../../stream/index.browser.js";
 import { commentsPath, commentsRelTargetFromWorksheetName, ctrlPropPath, 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 "../utils/ooxml-paths.js";
+import { PassthroughManager } from "../utils/passthrough-manager.js";
 class StreamingZipWriterAdapter {
     constructor(options) {
         this.events = new Map();
@@ -201,6 +202,7 @@ class XLSX {
         this.addDrawings(zip, model);
         this.addTables(zip, model);
         this.addPivotTables(zip, model);
+        this.addPassthrough(zip, model);
         await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
         await this.addFeaturePropertyBag(zip, model);
         await this.addMedia(zip, model);
@@ -300,8 +302,12 @@ class XLSX {
      * 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 = {
+    /**
+     * Create an empty model for parsing XLSX files.
+     * Shared by loadFromZipEntries and loadFromFiles.
+     */
+    createEmptyModel() {
+        return {
             worksheets: [],
             worksheetHash: {},
             worksheetRels: [],
@@ -310,6 +316,8 @@ class XLSX {
             mediaIndex: {},
             drawings: {},
             drawingRels: {},
+            // Raw drawing XML data for passthrough (when drawing contains chart references)
+            rawDrawings: {},
             comments: {},
             tables: {},
             vmlDrawings: {},
@@ -317,8 +325,104 @@ class XLSX {
             pivotTableRels: {},
             pivotCacheDefinitions: {},
             pivotCacheDefinitionRels: {},
-            pivotCacheRecords: {}
+            pivotCacheRecords: {},
+            // Passthrough storage for unknown/unsupported files (charts, etc.)
+            passthrough: {}
         };
+    }
+    /**
+     * Collect all data from a stream into a single Uint8Array.
+     * Reusable helper for passthrough and drawing processing.
+     */
+    async collectStreamData(stream) {
+        const chunks = [];
+        await new Promise((resolve, reject) => {
+            stream.on("data", (chunk) => {
+                if (typeof chunk === "string") {
+                    chunks.push(new TextEncoder().encode(chunk));
+                }
+                else if (chunk instanceof Uint8Array) {
+                    chunks.push(chunk);
+                }
+                else {
+                    chunks.push(new Uint8Array(chunk));
+                }
+            });
+            stream.on("end", () => resolve());
+            stream.on("error", reject);
+        });
+        return concatUint8Arrays(chunks);
+    }
+    /**
+     * Check if a drawing has chart references in its relationships
+     */
+    drawingHasChartReference(drawing) {
+        return (drawing.rels && drawing.rels.some((rel) => rel.Target && rel.Target.includes("/charts/")));
+    }
+    /**
+     * Check if a drawing rels list references charts.
+     * Used to decide whether we need to keep raw drawing XML for passthrough.
+     */
+    drawingRelsHasChartReference(drawingRels) {
+        return (Array.isArray(drawingRels) &&
+            drawingRels.some(rel => typeof rel?.Target === "string" && rel.Target.includes("/charts/")));
+    }
+    /**
+     * Process a known OOXML entry (workbook, styles, shared strings, etc.)
+     * Returns true if handled, false if should be passed to _processDefaultEntry
+     */
+    async _processKnownEntry(stream, model, entryName, options) {
+        const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
+        if (sheetNo !== undefined) {
+            await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
+            return true;
+        }
+        switch (entryName) {
+            case OOXML_PATHS.rootRels:
+                model.globalRels = await this.parseRels(stream);
+                return true;
+            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;
+                return true;
+            }
+            case OOXML_PATHS.xlSharedStrings:
+                model.sharedStrings = new SharedStringsXform();
+                await model.sharedStrings.parseStream(stream);
+                return true;
+            case OOXML_PATHS.xlWorkbookRels:
+                model.workbookRels = await this.parseRels(stream);
+                return true;
+            case OOXML_PATHS.docPropsApp: {
+                const appXform = new AppXform();
+                const appProperties = await appXform.parseStream(stream);
+                if (appProperties) {
+                    model.company = appProperties.company;
+                    model.manager = appProperties.manager;
+                }
+                return true;
+            }
+            case OOXML_PATHS.docPropsCore: {
+                const coreXform = new CoreXform();
+                const coreProperties = await coreXform.parseStream(stream);
+                Object.assign(model, coreProperties);
+                return true;
+            }
+            case OOXML_PATHS.xlStyles:
+                model.styles = new StylesXform();
+                await model.styles.parseStream(stream);
+                return true;
+            default:
+                return false;
+        }
+    }
+    async loadFromZipEntries(entries, options) {
+        const model = this.createEmptyModel();
         for await (const entry of entries) {
             let drained = false;
             const drainEntry = async () => {
@@ -335,58 +439,12 @@ class XLSX {
             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);
-                        if (appProperties) {
-                            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;
+                const handled = await this._processKnownEntry(stream, model, entryName, options);
+                if (!handled) {
+                    const defaultHandled = await this._processDefaultEntry(stream, model, entryName);
+                    if (!defaultHandled) {
+                        // Important for true streaming parsers: always consume unknown entries
+                        await drainEntry();
                     }
                 }
             }
@@ -500,6 +558,15 @@ class XLSX {
                 drawingXform.reconcile(drawing, drawingOptions);
             }
         });
+        // Trim raw drawings for non-chart drawings to avoid bloating the serialized workbook model.
+        if (model.rawDrawings && model.drawingRels) {
+            for (const name of Object.keys(model.rawDrawings)) {
+                const drawingRel = model.drawingRels[name];
+                if (drawingRel && !this.drawingRelsHasChartReference(drawingRel)) {
+                    delete model.rawDrawings[name];
+                }
+            }
+        }
         // reconcile tables with the default styles
         const tableOptions = {
             styles: model.styles
@@ -516,6 +583,7 @@ class XLSX {
             mediaIndex: model.mediaIndex,
             date1904: model.properties && model.properties.date1904,
             drawings: model.drawings,
+            drawingRels: model.drawingRels,
             comments: model.comments,
             tables: model.tables,
             vmlDrawings: model.vmlDrawings,
@@ -692,9 +760,15 @@ class XLSX {
         }
     }
     async _processDrawingEntry(entry, model, name) {
+        // Collect raw data first so we can preserve drawings that reference charts.
+        const rawData = await this.collectStreamData(entry);
+        // Parse the drawing for normal processing (images, etc.)
         const xform = new DrawingXform();
-        const drawing = await xform.parseStream(entry);
+        const xmlString = this.bufferToString(rawData);
+        const drawing = await xform.parseStream(this.createTextStream(xmlString));
         model.drawings[name] = drawing;
+        // Store raw data; reconcile() may later drop it if charts are not referenced.
+        model.rawDrawings[name] = rawData;
     }
     async _processDrawingRelsEntry(entry, model, name) {
         const xform = new RelationshipsXform();
@@ -769,24 +843,7 @@ class XLSX {
     // 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 model = this.createEmptyModel();
         const entries = Object.keys(zipData).map(name => ({
             name,
             dir: name.endsWith("/"),
@@ -800,54 +857,10 @@ class XLSX {
                 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);
-                            if (appProperties) {
-                                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);
-                    }
+                const handled = await this._processKnownEntry(stream, model, entryName, options);
+                if (!handled) {
+                    // Pass raw entry data for drawings to enable passthrough
+                    await this._processDefaultEntry(stream, model, entryName, entry.data);
                 }
             }
         }
@@ -857,11 +870,11 @@ class XLSX {
     }
     /**
      * Process default entries (drawings, comments, tables, etc.)
+     * @param rawData Optional raw entry data for passthrough preservation (used by loadFromFiles)
      */
-    async _processDefaultEntry(stream, model, entryName) {
-        const worksheetRelsSheetNo = getWorksheetNoFromWorksheetRelsPath(entryName);
-        if (worksheetRelsSheetNo !== undefined) {
-            const sheetNo = worksheetRelsSheetNo;
+    async _processDefaultEntry(stream, model, entryName, rawData) {
+        const sheetNo = getWorksheetNoFromWorksheetRelsPath(entryName);
+        if (sheetNo !== undefined) {
             await this._processWorksheetRelsEntry(stream, model, sheetNo);
             return true;
         }
@@ -873,6 +886,10 @@ class XLSX {
         const drawingName = getDrawingNameFromPath(entryName);
         if (drawingName) {
             await this._processDrawingEntry(stream, model, drawingName);
+            // For loadFromFiles path, store raw data for passthrough (drawings with charts)
+            if (rawData) {
+                model.rawDrawings[drawingName] = rawData;
+            }
             return true;
         }
         const drawingRelsName = getDrawingNameFromRelsPath(entryName);
@@ -927,8 +944,27 @@ class XLSX {
             await this._processPivotCacheRecordsEntry(stream, model, pivotCacheRecordsName);
             return true;
         }
+        // Store passthrough files (charts, etc.) for preservation
+        if (PassthroughManager.isPassthroughPath(entryName)) {
+            // If raw data is available (loadFromFiles path), use it directly
+            if (rawData) {
+                model.passthrough[entryName] = rawData;
+            }
+            else {
+                await this._processPassthroughEntry(stream, model, entryName);
+            }
+            return true;
+        }
         return false;
     }
+    /**
+     * Store a passthrough file for preservation during read/write cycles.
+     * These files are not parsed but stored as raw bytes to be written back unchanged.
+     */
+    async _processPassthroughEntry(stream, model, entryName) {
+        const data = await this.collectStreamData(stream);
+        model.passthrough[entryName] = data;
+    }
     // ===========================================================================
     // Write methods - shared by all platforms
     // ===========================================================================
@@ -1071,14 +1107,46 @@ class XLSX {
     addDrawings(zip, model) {
         const drawingXform = new DrawingXform();
         const relsXform = new RelationshipsXform();
+        const rawDrawings = model.rawDrawings || {};
         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) });
+                // Check if drawing rels contain chart references using helper
+                const hasChartReference = this.drawingHasChartReference(drawing);
+                if (hasChartReference && rawDrawings[drawing.name]) {
+                    // Use raw data for drawings with chart references (passthrough)
+                    zip.append(rawDrawings[drawing.name], { name: drawingPath(drawing.name) });
+                }
+                else {
+                    // Use regenerated XML for normal drawings (images, shapes)
+                    // Filter out invalid anchors (null, undefined, or missing content)
+                    const filteredAnchors = (drawing.anchors || []).filter((a) => {
+                        if (a == null) {
+                            return false;
+                        }
+                        // Form controls have range.br and shape properties
+                        if (a.range?.br && a.shape) {
+                            return true;
+                        }
+                        // One-cell anchors need a valid picture
+                        if (!a.br && !a.picture) {
+                            return false;
+                        }
+                        // Two-cell anchors need either picture or shape
+                        if (a.br && !a.picture && !a.shape) {
+                            return false;
+                        }
+                        return true;
+                    });
+                    const drawingForWrite = drawing.anchors
+                        ? { ...drawing, anchors: filteredAnchors }
+                        : drawing;
+                    drawingXform.prepare(drawingForWrite);
+                    const xml = drawingXform.toXml(drawingForWrite);
+                    zip.append(xml, { name: drawingPath(drawing.name) });
+                }
+                const relsXml = relsXform.toXml(drawing.rels);
+                zip.append(relsXml, { name: drawingRelsPath(drawing.name) });
             }
         });
     }
@@ -1093,6 +1161,15 @@ class XLSX {
             });
         });
     }
+    /**
+     * Write passthrough files (charts, etc.) that were preserved during read.
+     * These files are written back unchanged to preserve unsupported features.
+     */
+    addPassthrough(zip, model) {
+        const passthroughManager = new PassthroughManager();
+        passthroughManager.fromRecord(model.passthrough || {});
+        passthroughManager.writeToZip(zip);
+    }
     addPivotTables(zip, model) {
         if (!model.pivotTables.length) {
             return;
@@ -1185,6 +1262,11 @@ class XLSX {
         });
         // ContentTypesXform expects this flag
         model.hasCheckboxes = model.styles.hasCheckboxes;
+        // Build passthroughContentTypes for ContentTypesXform using PassthroughManager
+        const passthrough = model.passthrough || {};
+        const passthroughManager = new PassthroughManager();
+        passthroughManager.fromRecord(passthrough);
+        model.passthroughContentTypes = passthroughManager.getContentTypes();
     }
 }
 XLSX.RelType = RelType;

package/dist/cjs/modules/csv/csv.browser.js

@@ -119,7 +119,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const rows = (0, csv_core_1.parseCsv)(str, options?.parserOptions);
         for (const row of rows) {
@@ -161,7 +161,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const parser = new csv_stream_1.CsvParserStream(options?.parserOptions);
         return new Promise((resolve, reject) => {
@@ -231,7 +231,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const parser = new csv_stream_1.CsvParserStream(options?.parserOptions);
         parser.on("data", (row) => worksheet.addRow(row.map(map)));

package/dist/cjs/modules/excel/utils/passthrough-manager.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * PassthroughManager - Manages passthrough files for round-trip preservation
+ *
+ * This module handles files that are not fully parsed by the library but need to be
+ * preserved during read/write cycles (e.g., charts, sparklines, slicers).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassthroughManager = void 0;
+// Pre-compiled regex patterns for content type detection (performance optimization)
+const chartXmlRegex = /^xl\/charts\/chart\d+\.xml$/;
+const chartStyleXmlRegex = /^xl\/charts\/style\d+\.xml$/;
+const chartColorsXmlRegex = /^xl\/charts\/colors\d+\.xml$/;
+/**
+ * Content type definitions for passthrough files
+ */
+const PASSTHROUGH_CONTENT_TYPES = new Map([
+    [chartXmlRegex, "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"],
+    [chartStyleXmlRegex, "application/vnd.ms-office.chartstyle+xml"],
+    [chartColorsXmlRegex, "application/vnd.ms-office.chartcolorstyle+xml"]
+]);
+/**
+ * Passthrough path prefixes that should be preserved
+ */
+const PASSTHROUGH_PREFIXES = ["xl/charts/"];
+/**
+ * PassthroughManager handles storage and retrieval of passthrough files
+ * that need to be preserved during Excel read/write cycles.
+ */
+class PassthroughManager {
+    constructor() {
+        this.files = new Map();
+    }
+    /**
+     * Check if a path should be treated as passthrough
+     */
+    static isPassthroughPath(path) {
+        return PASSTHROUGH_PREFIXES.some(prefix => path.startsWith(prefix));
+    }
+    /**
+     * Get the content type for a passthrough file path
+     * @returns Content type string or undefined if unknown
+     */
+    static getContentType(path) {
+        // Chart relationships are handled by Default extension="rels"
+        if (path.startsWith("xl/charts/_rels/")) {
+            return undefined;
+        }
+        for (const [regex, contentType] of PASSTHROUGH_CONTENT_TYPES) {
+            if (regex.test(path)) {
+                return contentType;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Add a file to passthrough storage
+     */
+    add(path, data) {
+        this.files.set(path, data);
+    }
+    /**
+     * Get a file from passthrough storage
+     */
+    get(path) {
+        return this.files.get(path);
+    }
+    /**
+     * Check if a file exists in passthrough storage
+     */
+    has(path) {
+        return this.files.has(path);
+    }
+    /**
+     * Get all stored paths
+     */
+    getPaths() {
+        return [...this.files.keys()];
+    }
+    /**
+     * Get all files as a record (for serialization)
+     */
+    toRecord() {
+        const record = {};
+        for (const [path, data] of this.files) {
+            record[path] = data;
+        }
+        return record;
+    }
+    /**
+     * Load files from a record (for deserialization)
+     */
+    fromRecord(record) {
+        this.files.clear();
+        for (const [path, data] of Object.entries(record)) {
+            this.files.set(path, data);
+        }
+    }
+    /**
+     * Get content types for all stored files that have known types
+     */
+    getContentTypes() {
+        const contentTypes = [];
+        for (const path of this.files.keys()) {
+            const contentType = PassthroughManager.getContentType(path);
+            if (contentType) {
+                contentTypes.push({ partName: path, contentType });
+            }
+        }
+        return contentTypes;
+    }
+    /**
+     * Write all passthrough files to a ZIP writer
+     */
+    writeToZip(zip) {
+        for (const [path, data] of this.files) {
+            zip.append(data, { name: path });
+        }
+    }
+    /**
+     * Clear all stored files
+     */
+    clear() {
+        this.files.clear();
+    }
+    /**
+     * Get the number of stored files
+     */
+    get size() {
+        return this.files.size;
+    }
+}
+exports.PassthroughManager = PassthroughManager;

package/dist/cjs/modules/excel/workbook.js

@@ -41,6 +41,8 @@ class Workbook {
         this.views = [];
         this.media = [];
         this.pivotTables = [];
+        this._passthrough = {};
+        this._rawDrawings = {};
         this._definedNames = new defined_names_1.DefinedNames();
     }
     // ===========================================================================
@@ -254,7 +256,9 @@ class Workbook {
             themes: this._themes,
             media: this.media,
             pivotTables: this.pivotTables,
-            calcProperties: this.calcProperties
+            calcProperties: this.calcProperties,
+            passthrough: this._passthrough,
+            rawDrawings: this._rawDrawings
         };
     }
     set model(value) {
@@ -295,6 +299,10 @@ class Workbook {
         // Handle pivot tables - either newly created or loaded from file
         // Loaded pivot tables come from loadedPivotTables after reconciliation
         this.pivotTables = value.pivotTables || value.loadedPivotTables || [];
+        // Preserve passthrough files (charts, etc.) for round-trip preservation
+        this._passthrough = value.passthrough || {};
+        // Preserve raw drawing data for drawings with chart references
+        this._rawDrawings = value.rawDrawings || {};
     }
 }
 exports.Workbook = Workbook;

package/dist/cjs/modules/excel/worksheet.js

@@ -900,7 +900,8 @@ class Worksheet {
             tables: Object.values(this.tables).map(table => table.model),
             pivotTables: this.pivotTables,
             conditionalFormattings: this.conditionalFormattings,
-            formControls: this.formControls.map(fc => fc.model)
+            formControls: this.formControls.map(fc => fc.model),
+            drawing: this._drawing
         };
         // =================================================
         // columns
@@ -968,6 +969,8 @@ class Worksheet {
         this.conditionalFormattings = value.conditionalFormattings;
         // Form controls are currently write-only (not parsed from XLSX)
         this.formControls = [];
+        // Preserve loaded drawing data (charts, etc.)
+        this._drawing = value.drawing;
     }
 }
 exports.Worksheet = Worksheet;