@cj-tech-master/excelts 4.2.3 → 5.0.0-canary.20260123012457.1fdf506

package/dist/browser/modules/csv/csv-core.d.ts

@@ -58,15 +58,6 @@ export interface CsvParseOptions {
     renameHeaders?: boolean;
     /** Comment character - lines starting with this are ignored */
     comment?: string;
-    /**
-     * Decimal separator used when parsing numbers from CSV (default: ".").
-     *
-     * Note: core CSV parsing returns strings; number conversion is handled by higher-level
-     * consumers (e.g. the default value mapper in the CSV module).
-     *
-     * @deprecated Use CsvReadOptions.valueMapperOptions.decimalSeparator instead.
-     */
-    decimalSeparator?: "." | ",";
     /** Maximum number of data rows to parse (excluding header) */
     maxRows?: number;
     /** Number of lines to skip at the beginning (before header detection) */

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

@@ -112,7 +112,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 = parseCsv(str, options?.parserOptions);
         for (const row of rows) {
@@ -154,7 +154,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 CsvParserStream(options?.parserOptions);
         return new Promise((resolve, reject) => {
@@ -224,7 +224,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 CsvParserStream(options?.parserOptions);
         parser.on("data", (row) => worksheet.addRow(row.map(map)));

package/dist/browser/modules/excel/column.d.ts

@@ -11,6 +11,8 @@ export interface ColumnDefn {
     outlineLevel?: number;
     hidden?: boolean;
     style?: Partial<Style>;
+    /** Whether the column width is auto-fitted to content */
+    bestFit?: boolean;
 }
 export interface ColumnModel {
     min: number;
@@ -21,6 +23,7 @@ export interface ColumnModel {
     hidden?: boolean;
     outlineLevel?: number;
     collapsed?: boolean;
+    bestFit?: boolean;
 }
 /**
  * Column defines the column properties for 1 column.
@@ -36,6 +39,8 @@ declare class Column {
     width?: number;
     private _hidden;
     private _outlineLevel;
+    /** Whether the column width is auto-fitted to content */
+    bestFit?: boolean;
     /** Styles applied to the column */
     style: Partial<Style>;
     constructor(worksheet: Worksheet, number: number, defn?: ColumnDefn | false);

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

@@ -38,7 +38,8 @@ class Column {
             width: this.width,
             style: this.style,
             hidden: this.hidden,
-            outlineLevel: this.outlineLevel
+            outlineLevel: this.outlineLevel,
+            bestFit: this.bestFit
         };
     }
     set defn(value) {
@@ -55,6 +56,7 @@ class Column {
             // headers must be set after style
             this.header = value.header;
             this._hidden = !!value.hidden;
+            this.bestFit = value.bestFit;
         }
         else {
             delete this._header;
@@ -62,6 +64,7 @@ class Column {
             delete this.width;
             this.style = {};
             this.outlineLevel = 0;
+            delete this.bestFit;
         }
     }
     /**
@@ -151,6 +154,7 @@ class Column {
         return (this.width === model.width &&
             this.hidden === model.hidden &&
             this.outlineLevel === model.outlineLevel &&
+            this.bestFit === model.bestFit &&
             isEqual(this.style, model.style));
     }
     get isDefault() {
@@ -163,6 +167,9 @@ class Column {
         if (this.outlineLevel) {
             return false;
         }
+        if (this.bestFit) {
+            return false;
+        }
         const s = this.style;
         if (s && (s.font || s.numFmt || s.alignment || s.border || s.fill || s.protection)) {
             return false;
@@ -313,7 +320,8 @@ class Column {
                         isCustomWidth: column.isCustomWidth,
                         hidden: column.hidden,
                         outlineLevel: column.outlineLevel,
-                        collapsed: column.collapsed
+                        collapsed: column.collapsed,
+                        bestFit: column.bestFit
                     };
                     cols.push(col);
                 }

package/dist/browser/modules/excel/row.d.ts

@@ -15,6 +15,7 @@ export interface RowModel {
     hidden: boolean;
     outlineLevel: number;
     collapsed: boolean;
+    dyDescent?: number;
 }
 declare class Row {
     private _worksheet;
@@ -24,6 +25,7 @@ declare class Row {
     private _hidden?;
     private _outlineLevel?;
     height?: number;
+    dyDescent?: number;
     constructor(worksheet: Worksheet, number: number);
     /**
      * The row number

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

@@ -388,7 +388,8 @@ class Row {
                 style: this.style,
                 hidden: this.hidden,
                 outlineLevel: this.outlineLevel,
-                collapsed: this.collapsed
+                collapsed: this.collapsed,
+                dyDescent: this.dyDescent
             }
             : null;
     }
@@ -435,6 +436,7 @@ class Row {
         }
         this.hidden = value.hidden;
         this.outlineLevel = value.outlineLevel || 0;
+        this.dyDescent = value.dyDescent;
         this.style = (value.style && JSON.parse(JSON.stringify(value.style))) || {};
     }
 }

package/dist/browser/modules/excel/utils/parse-sax.d.ts

@@ -54,7 +54,6 @@ export declare class SaxesParser {
     private positionAtNewLine;
     private chunkPosition;
     ENTITIES: Record<string, string>;
-    private nsPrefix;
     private textHandler?;
     private openTagHandler?;
     private closeTagHandler?;
@@ -63,7 +62,6 @@ export declare class SaxesParser {
     get closed(): boolean;
     get position(): number;
     private _init;
-    private stripNsPrefix;
     on(name: "text", handler: TextHandler): void;
     on(name: "opentag", handler: OpenTagHandler): void;
     on(name: "closetag", handler: CloseTagHandler): void;
@@ -108,7 +106,6 @@ export declare class SaxesParser {
     private skipSpaces;
     private openTag;
     private openSelfClosingTag;
-    private processAttributes;
     private closeTag;
     private end;
 }

package/dist/browser/modules/excel/utils/parse-sax.js

@@ -142,12 +142,6 @@ const XML_ENTITIES = {
     quot: '"',
     apos: "'"
 };
-// HAN CELL namespace prefix normalization
-// HAN CELL uses non-standard namespace prefixes (ep:, cp:, dc:, etc.)
-// The x: prefix for spreadsheetml is detected dynamically from xmlns declarations
-// See: https://github.com/exceljs/exceljs/issues/3014
-const HAN_CELL_PREFIXES = /^(ep|cp|dc|dcterms|dcmitype|vt):/;
-const SPREADSHEETML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
 // ============================================================================
 // Parser States
 // ============================================================================
@@ -208,8 +202,6 @@ export class SaxesParser {
         this.chunkPosition = 0;
         // Entity storage
         this.ENTITIES = { ...XML_ENTITIES };
-        // HAN CELL compatibility: spreadsheetml namespace prefix (e.g., "x")
-        this.nsPrefix = null;
         this.trackPosition = opt?.position !== false;
         this.fileName = opt?.fileName;
         this.fragment = opt?.fragment ?? false;
@@ -244,14 +236,6 @@ export class SaxesParser {
         this.chunk = "";
         this.i = 0;
         this.prevI = 0;
-        this.nsPrefix = null;
-    }
-    // Strip HAN CELL namespace prefixes from element names
-    stripNsPrefix(name) {
-        const n = name.replace(HAN_CELL_PREFIXES, "");
-        return this.nsPrefix && n.startsWith(this.nsPrefix + ":")
-            ? n.slice(this.nsPrefix.length + 1)
-            : n;
     }
     on(name, handler) {
         switch (name) {
@@ -667,8 +651,9 @@ export class SaxesParser {
             this.name += charFromCode(c);
             return;
         }
+        // Tag name complete
         this.tag = {
-            name: this.stripNsPrefix(this.name),
+            name: this.name,
             attributes: Object.create(null),
             isSelfClosing: false
         };
@@ -1107,7 +1092,11 @@ export class SaxesParser {
     openTag() {
         const tag = this.tag;
         tag.isSelfClosing = false;
-        this.processAttributes(tag);
+        // Copy attributes from list to object
+        for (const { name, value } of this.attribList) {
+            tag.attributes[name] = value;
+        }
+        this.attribList = [];
         this.openTagHandler?.(tag);
         this.tags.push(tag);
         this.name = "";
@@ -1116,7 +1105,11 @@ export class SaxesParser {
     openSelfClosingTag() {
         const tag = this.tag;
         tag.isSelfClosing = true;
-        this.processAttributes(tag);
+        // Copy attributes from list to object
+        for (const { name, value } of this.attribList) {
+            tag.attributes[name] = value;
+        }
+        this.attribList = [];
         this.openTagHandler?.(tag);
         this.closeTagHandler?.(tag);
         if (this.tags.length === 0) {
@@ -1125,20 +1118,8 @@ export class SaxesParser {
         this.name = "";
         this.state = S_TEXT;
     }
-    // Process attributes and detect spreadsheetml namespace prefix
-    processAttributes(tag) {
-        for (const { name, value } of this.attribList) {
-            tag.attributes[name] = value;
-            if (name.startsWith("xmlns:") && value === SPREADSHEETML_NS) {
-                this.nsPrefix = name.slice(6);
-                tag.name = this.stripNsPrefix(tag.name);
-            }
-        }
-        this.attribList = [];
-    }
     closeTag() {
-        const { tags } = this;
-        const name = this.stripNsPrefix(this.name);
+        const { tags, name } = this;
         this.state = S_TEXT;
         this.name = "";
         if (name === "") {

package/dist/browser/modules/excel/utils/passthrough-manager.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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).
+ */
+/**
+ * Content type entry for ZIP content types
+ */
+export interface PassthroughContentType {
+    partName: string;
+    contentType: string;
+}
+/**
+ * ZIP writer interface for passthrough files
+ */
+export interface IPassthroughZipWriter {
+    append(data: Uint8Array, options: {
+        name: string;
+    }): void;
+}
+/**
+ * PassthroughManager handles storage and retrieval of passthrough files
+ * that need to be preserved during Excel read/write cycles.
+ */
+export declare class PassthroughManager {
+    private files;
+    /**
+     * Check if a path should be treated as passthrough
+     */
+    static isPassthroughPath(path: string): boolean;
+    /**
+     * Get the content type for a passthrough file path
+     * @returns Content type string or undefined if unknown
+     */
+    static getContentType(path: string): string | undefined;
+    /**
+     * Add a file to passthrough storage
+     */
+    add(path: string, data: Uint8Array): void;
+    /**
+     * Get a file from passthrough storage
+     */
+    get(path: string): Uint8Array | undefined;
+    /**
+     * Check if a file exists in passthrough storage
+     */
+    has(path: string): boolean;
+    /**
+     * Get all stored paths
+     */
+    getPaths(): string[];
+    /**
+     * Get all files as a record (for serialization)
+     */
+    toRecord(): Record<string, Uint8Array>;
+    /**
+     * Load files from a record (for deserialization)
+     */
+    fromRecord(record: Record<string, Uint8Array>): void;
+    /**
+     * Get content types for all stored files that have known types
+     */
+    getContentTypes(): PassthroughContentType[];
+    /**
+     * Write all passthrough files to a ZIP writer
+     */
+    writeToZip(zip: IPassthroughZipWriter): void;
+    /**
+     * Clear all stored files
+     */
+    clear(): void;
+    /**
+     * Get the number of stored files
+     */
+    get size(): number;
+}

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

@@ -0,0 +1,129 @@
+/**
+ * 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).
+ */
+// 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.
+ */
+export 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;
+    }
+}

package/dist/browser/modules/excel/workbook.d.ts

@@ -55,6 +55,12 @@ export interface WorkbookModel {
     /** Loaded pivot tables from file - used during reconciliation */
     loadedPivotTables?: any[];
     calcProperties: Partial<CalculationProperties>;
+    /** Passthrough files (charts, etc.) preserved for round-trip */
+    passthrough?: Record<string, Uint8Array>;
+    /** Raw drawing XML data for passthrough (when drawing contains chart references) */
+    rawDrawings?: Record<string, Uint8Array>;
+    /** Default font preserved from the original file for round-trip fidelity */
+    defaultFont?: any;
 }
 declare class Workbook {
     /**
@@ -94,6 +100,12 @@ declare class Workbook {
     private _worksheets;
     private _definedNames;
     private _themes?;
+    /** Passthrough files (charts, etc.) preserved for round-trip */
+    private _passthrough;
+    /** Raw drawing XML data for passthrough (when drawing contains chart references) */
+    private _rawDrawings;
+    /** Default font preserved from original file for round-trip fidelity */
+    private _defaultFont?;
     private _xlsx?;
     private _csv?;
     constructor();

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

@@ -38,6 +38,8 @@ class Workbook {
         this.views = [];
         this.media = [];
         this.pivotTables = [];
+        this._passthrough = {};
+        this._rawDrawings = {};
         this._definedNames = new DefinedNames();
     }
     // ===========================================================================
@@ -251,7 +253,10 @@ class Workbook {
             themes: this._themes,
             media: this.media,
             pivotTables: this.pivotTables,
-            calcProperties: this.calcProperties
+            calcProperties: this.calcProperties,
+            passthrough: this._passthrough,
+            rawDrawings: this._rawDrawings,
+            defaultFont: this._defaultFont
         };
     }
     set model(value) {
@@ -292,6 +297,12 @@ 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 || {};
+        // Preserve default font for round-trip fidelity
+        this._defaultFont = value.defaultFont;
     }
 }
 // ===========================================================================

package/dist/browser/modules/excel/worksheet.d.ts

@@ -111,6 +111,8 @@ interface WorksheetModel {
     dimensions?: Range;
     merges?: string[];
     mergeCells?: string[];
+    /** Loaded drawing data (for charts, etc.) - preserved for round-trip */
+    drawing?: any;
 }
 declare class Worksheet {
     private _workbook;
@@ -139,6 +141,8 @@ declare class Worksheet {
     conditionalFormattings: ConditionalFormattingOptions[];
     formControls: FormCheckbox[];
     private _headerRowCount?;
+    /** Loaded drawing data (for charts, etc.) - preserved for round-trip */
+    private _drawing;
     constructor(options: WorksheetOptions);
     get name(): string;
     set name(name: string | undefined);

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

@@ -897,7 +897,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
@@ -965,6 +966,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;
     }
 }
 export { Worksheet };

package/dist/browser/modules/excel/xlsx/xform/base-xform.js

@@ -1,5 +1,41 @@
 import { parseSax } from "../../utils/parse-sax.js";
 import { XmlStream } from "../../utils/xml-stream.js";
+// HAN CELL namespace prefix normalization
+// HAN CELL uses non-standard namespace prefixes (ep:, cp:, dc:, etc.)
+// See: https://github.com/exceljs/exceljs/issues/3014
+const HAN_CELL_PREFIXES = new Set(["ep", "cp", "dc", "dcterms", "dcmitype", "vt"]);
+const SPREADSHEETML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+// Detect HAN CELL mode from first tag. Returns:
+// - undefined: normal file (no prefix handling needed)
+// - null: HAN CELL file without spreadsheetml prefix (uses static prefixes only)
+// - string: HAN CELL file with spreadsheetml prefix (e.g., "x")
+function detectHanCellPrefix(tagName, attrs) {
+    for (const key in attrs) {
+        if (key.length > 6 && key.startsWith("xmlns:")) {
+            const prefix = key.slice(6);
+            // Check for spreadsheetml namespace prefix
+            if (attrs[key] === SPREADSHEETML_NS) {
+                return prefix;
+            }
+            // Check if xmlns declares a known HAN CELL prefix (e.g., xmlns:dc, xmlns:dcterms)
+            if (HAN_CELL_PREFIXES.has(prefix)) {
+                return null;
+            }
+        }
+    }
+    // Check if tag name has a known static prefix
+    const i = tagName.indexOf(":");
+    return i !== -1 && HAN_CELL_PREFIXES.has(tagName.slice(0, i)) ? null : undefined;
+}
+// Strip known namespace prefix from element name
+function stripPrefix(name, nsPrefix) {
+    const i = name.indexOf(":");
+    if (i === -1) {
+        return name;
+    }
+    const p = name.slice(0, i);
+    return p === nsPrefix || HAN_CELL_PREFIXES.has(p) ? name.slice(i + 1) : name;
+}
 // Base class for Xforms
 class BaseXform {
     // ============================================================
@@ -51,19 +87,50 @@ class BaseXform {
         // destroys the underlying stream and can surface as AbortError (ABORT_ERR).
         let done = false;
         let finalModel;
+        // HAN CELL compatibility: 0 = not checked, 1 = normal file, 2 = HAN CELL file
+        let nsMode = 0;
+        let nsPrefix = null;
         for await (const events of saxParser) {
             if (done) {
                 continue;
             }
             for (const { eventType, value } of events) {
                 if (eventType === "opentag") {
+                    // Fast path for normal Excel files (majority case)
+                    if (nsMode === 1) {
+                        this.parseOpen(value);
+                        continue;
+                    }
+                    // First tag - detect mode
+                    if (nsMode === 0) {
+                        const prefix = detectHanCellPrefix(value.name, value.attributes);
+                        if (prefix === undefined) {
+                            nsMode = 1;
+                            this.parseOpen(value);
+                            continue;
+                        }
+                        nsMode = 2;
+                        nsPrefix = prefix;
+                    }
+                    // HAN CELL mode - strip prefix
+                    value.name = stripPrefix(value.name, nsPrefix);
                     this.parseOpen(value);
                 }
                 else if (eventType === "text") {
                     this.parseText(value);
                 }
                 else if (eventType === "closetag") {
-                    if (!this.parseClose(value.name)) {
+                    // Fast path for normal files
+                    if (nsMode === 1) {
+                        if (!this.parseClose(value.name)) {
+                            done = true;
+                            finalModel = this.model;
+                            break;
+                        }
+                        continue;
+                    }
+                    // HAN CELL mode - strip prefix
+                    if (!this.parseClose(stripPrefix(value.name, nsPrefix))) {
                         done = true;
                         finalModel = this.model;
                         break;