@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

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

@@ -0,0 +1,790 @@
+/**
+ * Workbook - Cross-platform Excel Workbook (Browser Version)
+ *
+ * Base implementation with all platform-agnostic functionality.
+ * Node.js version (workbook.ts) extends this with file system support for CSV.
+ *
+ * Features:
+ * - xlsx: File/stream/buffer support (file operations Node.js only)
+ * - csv: CSV read/write support (file operations Node.js only)
+ * - streaming: createStreamWriter/createStreamReader for large files
+ */
+import { Worksheet } from "./worksheet.js";
+import { DefinedNames } from "./defined-names.js";
+import { XLSX } from "./xlsx/xlsx.browser.js";
+import { WorkbookWriter } from "./stream/workbook-writer.browser.js";
+import { WorkbookReader } from "./stream/workbook-reader.browser.js";
+import { DateParser, DateFormatter } from "../../utils/datetime.js";
+import { parseCsv } from "../csv/parse/index.js";
+import { formatCsv } from "../csv/format/index.js";
+import { CsvParserStream, CsvFormatterStream } from "../csv/stream/index.js";
+import { parseNumberFromCsv } from "../csv/utils/number.js";
+import { ExcelDownloadError, ExcelNotSupportedError } from "./errors.js";
+import { pipeline } from "../stream/index.browser.js";
+import { readableStreamToAsyncIterable } from "../stream/utils.base.js";
+// =============================================================================
+// CSV Constants
+// =============================================================================
+const DEFAULT_DATE_FORMATS = [
+    "YYYY-MM-DD[T]HH:mm:ssZ",
+    "YYYY-MM-DD[T]HH:mm:ss",
+    "MM-DD-YYYY",
+    "YYYY-MM-DD"
+];
+const SpecialValues = {
+    true: true,
+    false: false,
+    "#N/A": { error: "#N/A" },
+    "#REF!": { error: "#REF!" },
+    "#NAME?": { error: "#NAME?" },
+    "#DIV/0!": { error: "#DIV/0!" },
+    "#NULL!": { error: "#NULL!" },
+    "#VALUE!": { error: "#VALUE!" },
+    "#NUM!": { error: "#NUM!" }
+};
+// =============================================================================
+// CSV Value Mappers (Internal)
+// =============================================================================
+/**
+ * Create a value mapper for parsing CSV values into Excel-compatible types.
+ * Converts strings to numbers, dates, booleans, and Excel error values.
+ */
+function createDefaultValueMapper(dateFormats, options) {
+    const dateParser = DateParser.create(dateFormats);
+    const decimalSeparator = options?.decimalSeparator ?? ".";
+    return function mapValue(datum) {
+        if (datum === "") {
+            return null;
+        }
+        if (typeof datum === "string") {
+            const datumNumber = parseNumberFromCsv(datum, decimalSeparator);
+            if (!Number.isNaN(datumNumber) && datumNumber !== Infinity) {
+                return datumNumber;
+            }
+        }
+        else {
+            const datumNumber = Number(datum);
+            if (!Number.isNaN(datumNumber) && datumNumber !== Infinity) {
+                return datumNumber;
+            }
+        }
+        const date = dateParser.parse(datum);
+        if (date) {
+            return date;
+        }
+        const special = SpecialValues[datum];
+        if (special !== undefined) {
+            return special;
+        }
+        return datum;
+    };
+}
+/**
+ * Create a value mapper for writing Excel values to CSV format.
+ * Handles hyperlinks, formulas, rich text, dates, errors, and objects.
+ */
+function createDefaultWriteMapper(dateFormat, dateUTC) {
+    const formatter = dateFormat
+        ? DateFormatter.create(dateFormat, { utc: dateUTC })
+        : DateFormatter.iso(dateUTC);
+    return function mapValue(value) {
+        if (value) {
+            if (value.text || value.hyperlink) {
+                return value.hyperlink || value.text || "";
+            }
+            if (value.formula || value.result) {
+                return value.result || "";
+            }
+            // Handle rich text - extract and concatenate all text fragments
+            if (value.richText && Array.isArray(value.richText)) {
+                return value.richText.map((r) => r.text).join("");
+            }
+            if (value instanceof Date) {
+                return formatter.format(value);
+            }
+            if (value.error) {
+                return value.error;
+            }
+            if (typeof value === "object") {
+                return JSON.stringify(value);
+            }
+        }
+        return value;
+    };
+}
+// =============================================================================
+// CSV Input Type Detection (Internal)
+// =============================================================================
+function isUrl(input) {
+    return typeof input === "string" && /^https?:\/\//i.test(input);
+}
+function isFile(input) {
+    return typeof File !== "undefined" && input instanceof File;
+}
+function isBlob(input) {
+    return typeof Blob !== "undefined" && input instanceof Blob && !isFile(input);
+}
+function isReadableStream(input) {
+    if (!input || typeof input !== "object") {
+        return false;
+    }
+    const obj = input;
+    return (typeof obj[Symbol.asyncIterator] === "function" ||
+        (typeof obj.pipe === "function" && typeof obj.on === "function"));
+}
+// =============================================================================
+// CSV Helper Functions (Internal)
+// =============================================================================
+function buildParserOptions(options) {
+    return {
+        delimiter: options?.delimiter ?? ",",
+        quote: options?.quote,
+        escape: options?.escape,
+        delimitersToGuess: options?.delimitersToGuess,
+        lineEnding: options?.lineEnding,
+        headers: options?.headers,
+        skipEmptyLines: options?.skipEmptyLines,
+        trim: options?.trim,
+        ltrim: options?.ltrim,
+        rtrim: options?.rtrim,
+        comment: options?.comment,
+        maxRows: options?.maxRows,
+        toLine: options?.toLine,
+        skipLines: options?.skipLines,
+        skipRows: options?.skipRows,
+        columnMismatch: options?.columnMismatch,
+        groupColumnsByName: options?.groupColumnsByName,
+        relaxQuotes: options?.relaxQuotes,
+        fastMode: options?.fastMode,
+        info: options?.info,
+        raw: options?.raw,
+        skipRecordsWithError: options?.skipRecordsWithError,
+        skipRecordsWithEmptyValues: options?.skipRecordsWithEmptyValues,
+        onSkip: options?.onSkip
+    };
+}
+function buildFormatterOptions(options) {
+    return {
+        delimiter: options?.delimiter ?? ",",
+        quote: options?.quote,
+        escape: options?.escape,
+        lineEnding: options?.lineEnding,
+        quoteColumns: options?.quoteColumns,
+        quoteHeaders: options?.quoteHeaders,
+        decimalSeparator: options?.decimalSeparator ?? ".",
+        escapeFormulae: options?.escapeFormulae,
+        writeHeaders: options?.writeHeaders
+    };
+}
+// =============================================================================
+// Workbook Class
+// =============================================================================
+class Workbook {
+    // ===========================================================================
+    // Constructor
+    // ===========================================================================
+    constructor() {
+        this.category = "";
+        this.company = "";
+        this.created = new Date();
+        this.description = "";
+        this.keywords = "";
+        this.manager = "";
+        this.modified = this.created;
+        this.properties = {};
+        this.calcProperties = {};
+        this._worksheets = [];
+        this.subject = "";
+        this.title = "";
+        this.views = [];
+        this.media = [];
+        this.pivotTables = [];
+        this._passthrough = {};
+        this._rawDrawings = {};
+        this._definedNames = new DefinedNames();
+    }
+    // ===========================================================================
+    // Format Operations (xlsx)
+    // ===========================================================================
+    /**
+     * xlsx file format operations
+     * Node.js: readFile, writeFile, read (stream), write (stream), load (buffer), writeBuffer
+     * Browser: load (buffer), writeBuffer
+     */
+    get xlsx() {
+        if (!this._xlsx) {
+            this._xlsx = new XLSX(this);
+        }
+        return this._xlsx;
+    }
+    // ===========================================================================
+    // CSV Operations
+    // ===========================================================================
+    /**
+     * Read CSV from any supported input source and add as worksheet
+     *
+     * @example
+     * ```ts
+     * // String
+     * await workbook.readCsv("a,b,c\n1,2,3");
+     *
+     * // URL
+     * await workbook.readCsv("https://example.com/data.csv");
+     *
+     * // File (browser)
+     * await workbook.readCsv(fileInput.files[0]);
+     *
+     * // Stream
+     * await workbook.readCsv(readableStream);
+     *
+     * // With options
+     * await workbook.readCsv(input, { delimiter: ";", sheetName: "Data" });
+     * ```
+     */
+    async readCsv(input, options) {
+        if (isUrl(input)) {
+            return this._readCsvUrl(input, options);
+        }
+        if (isFile(input)) {
+            return this._readCsvFile(input, options);
+        }
+        if (isBlob(input)) {
+            return this._readCsvBlob(input, options);
+        }
+        if (isReadableStream(input)) {
+            return this._readCsvStream(input, options);
+        }
+        return this._readCsvContent(input, options);
+    }
+    writeCsv(streamOrOptions, options) {
+        // If first argument is a stream (has write/end methods)
+        if (streamOrOptions && typeof streamOrOptions.write === "function") {
+            return this._writeCsvStream(streamOrOptions, options);
+        }
+        // Otherwise treat first argument as options
+        return this._writeCsvString(streamOrOptions);
+    }
+    /**
+     * Write worksheet to CSV buffer (Uint8Array)
+     *
+     * @example
+     * ```ts
+     * const buffer = await workbook.writeCsvBuffer();
+     * const buffer = await workbook.writeCsvBuffer({ delimiter: ";", sheetName: "Data" });
+     * ```
+     */
+    async writeCsvBuffer(options) {
+        const csvString = this._writeCsvString(options);
+        return new TextEncoder().encode(csvString);
+    }
+    /**
+     * Read CSV from file (Node.js only - throws in browser)
+     */
+    async readCsvFile(_filename, _options) {
+        throw new ExcelNotSupportedError("readCsvFile()", "not available in browser. Use readCsv(url) or readCsv(file) instead.");
+    }
+    /**
+     * Write CSV to file (Node.js only - throws in browser)
+     */
+    async writeCsvFile(_filename, _options) {
+        throw new ExcelNotSupportedError("writeCsvFile()", "not available in browser. Use writeCsv() and trigger a download instead.");
+    }
+    /**
+     * Create a readable stream that outputs CSV data
+     *
+     * @example
+     * ```ts
+     * const csvStream = workbook.createCsvReadStream();
+     * csvStream.pipe(response); // pipe to HTTP response
+     * ```
+     */
+    createCsvReadStream(options) {
+        const worksheet = this.getWorksheet(options?.sheetName || options?.sheetId);
+        const map = options?.map || createDefaultWriteMapper(options?.dateFormat, options?.dateUTC);
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        const formatter = new CsvFormatterStream(buildFormatterOptions(options));
+        if (worksheet) {
+            setTimeout(() => {
+                let lastRow = 1;
+                worksheet.eachRow((row, rowNumber) => {
+                    if (includeEmptyRows) {
+                        while (lastRow++ < rowNumber - 1) {
+                            formatter.write([]);
+                        }
+                    }
+                    const { values } = row;
+                    values.shift();
+                    formatter.write(values.map(map));
+                    lastRow = rowNumber;
+                });
+                formatter.end();
+            }, 0);
+        }
+        else {
+            setTimeout(() => formatter.end(), 0);
+        }
+        return formatter;
+    }
+    /**
+     * Create a writable stream that accepts CSV data and adds to worksheet
+     *
+     * @example
+     * ```ts
+     * const csvStream = workbook.createCsvWriteStream({ sheetName: "Data" });
+     * inputStream.pipe(csvStream);
+     * ```
+     */
+    createCsvWriteStream(options) {
+        const worksheet = this.addWorksheet(options?.sheetName);
+        const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
+        const decimalSeparator = options?.decimalSeparator;
+        const map = options?.map || createDefaultValueMapper(dateFormats, { decimalSeparator });
+        const parser = new CsvParserStream(buildParserOptions(options));
+        const useHeaders = !!options?.headers;
+        let headerRow = null;
+        // When headers option is enabled, listen for headers event to write header row first
+        if (useHeaders) {
+            parser.on("headers", (headers) => {
+                headerRow = headers;
+                worksheet.addRow(headers);
+            });
+        }
+        parser.on("data", (row) => {
+            // When headers: true, CsvParserStream emits objects; otherwise arrays
+            if (useHeaders && headerRow && row && typeof row === "object" && !Array.isArray(row)) {
+                // Convert object row to array using header order
+                const rowObj = row;
+                const rowArray = headerRow.map(h => rowObj[h]);
+                worksheet.addRow(rowArray.map(map));
+            }
+            else if (Array.isArray(row)) {
+                worksheet.addRow(row.map(map));
+            }
+        });
+        return parser;
+    }
+    // ===========================================================================
+    // CSV Internal Methods
+    // ===========================================================================
+    /** @internal */
+    _readCsvContent(content, options) {
+        let str;
+        if (typeof content === "string") {
+            str = content;
+        }
+        else if (content instanceof ArrayBuffer || content instanceof Uint8Array) {
+            str = new TextDecoder().decode(content);
+        }
+        else {
+            str = String(content);
+        }
+        const worksheet = this.addWorksheet(options?.sheetName);
+        const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
+        const decimalSeparator = options?.decimalSeparator;
+        const map = options?.map || createDefaultValueMapper(dateFormats, { decimalSeparator });
+        const result = parseCsv(str, buildParserOptions(options));
+        if (Array.isArray(result)) {
+            for (const row of result) {
+                worksheet.addRow(row.map(map));
+            }
+        }
+        else {
+            if (result.headers) {
+                worksheet.addRow(result.headers);
+            }
+            for (const rowObj of result.rows) {
+                const rowArray = result.headers.map(h => rowObj[h]);
+                worksheet.addRow(rowArray.map(map));
+            }
+        }
+        return worksheet;
+    }
+    /** @internal */
+    async _readCsvStream(stream, options) {
+        const worksheet = this.addWorksheet(options?.sheetName);
+        const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
+        const decimalSeparator = options?.decimalSeparator;
+        const map = options?.map || createDefaultValueMapper(dateFormats, { decimalSeparator });
+        const parser = new CsvParserStream(buildParserOptions(options));
+        const useHeaders = !!options?.headers;
+        let headerRow = null;
+        return new Promise((resolve, reject) => {
+            // When headers option is enabled, listen for headers event to write header row first
+            if (useHeaders) {
+                parser.on("headers", (headers) => {
+                    headerRow = headers;
+                    worksheet.addRow(headers);
+                });
+            }
+            parser.on("data", (row) => {
+                // When headers: true, CsvParserStream emits objects; otherwise arrays
+                if (useHeaders && headerRow && row && typeof row === "object" && !Array.isArray(row)) {
+                    // Convert object row to array using header order
+                    const rowObj = row;
+                    const rowArray = headerRow.map(h => rowObj[h]);
+                    worksheet.addRow(rowArray.map(map));
+                }
+                else if (Array.isArray(row)) {
+                    worksheet.addRow(row.map(map));
+                }
+            });
+            pipeline(stream, parser)
+                .then(() => resolve(worksheet))
+                .catch(reject);
+        });
+    }
+    async _readCsvUrl(url, options) {
+        const fetchOptions = {
+            method: options?.requestBody ? "POST" : "GET",
+            headers: options?.requestHeaders,
+            body: options?.requestBody,
+            credentials: options?.withCredentials ? "include" : "same-origin",
+            signal: options?.signal
+        };
+        const response = await fetch(url, fetchOptions);
+        if (!response.ok) {
+            throw new ExcelDownloadError(url, response.status, response.statusText);
+        }
+        if (options?.stream && response.body) {
+            const readable = readableStreamToAsyncIterable(response.body);
+            return this._readCsvStream(readable, options);
+        }
+        const text = await response.text();
+        return this._readCsvContent(text, options);
+    }
+    async _readCsvFile(file, options) {
+        const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024;
+        if ((options?.stream || file.size > LARGE_FILE_THRESHOLD) &&
+            typeof file.stream === "function") {
+            const readable = readableStreamToAsyncIterable(file.stream());
+            return this._readCsvStream(readable, options);
+        }
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            const encoding = options?.encoding ?? "UTF-8";
+            if (options?.onProgress) {
+                reader.onprogress = event => {
+                    options.onProgress(event.loaded, event.total || file.size);
+                };
+            }
+            reader.onload = event => {
+                try {
+                    const content = event.target?.result;
+                    resolve(this._readCsvContent(content, options));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            reader.onerror = () => reject(new Error(`Failed to read file: ${file.name}`));
+            reader.readAsText(file, encoding);
+        });
+    }
+    async _readCsvBlob(blob, options) {
+        const text = await blob.text();
+        return this._readCsvContent(text, options);
+    }
+    _writeCsvString(options) {
+        const worksheet = this.getWorksheet(options?.sheetName || options?.sheetId);
+        if (!worksheet) {
+            return "";
+        }
+        const map = options?.map || createDefaultWriteMapper(options?.dateFormat, options?.dateUTC);
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        const rows = [];
+        let lastRow = 1;
+        worksheet.eachRow((row, rowNumber) => {
+            if (includeEmptyRows) {
+                while (lastRow++ < rowNumber - 1) {
+                    rows.push([]);
+                }
+            }
+            const { values } = row;
+            values.shift();
+            rows.push(values.map(map));
+            lastRow = rowNumber;
+        });
+        return formatCsv(rows, buildFormatterOptions(options));
+    }
+    /** @internal */
+    async _writeCsvStream(stream, options) {
+        const worksheet = this.getWorksheet(options?.sheetName || options?.sheetId);
+        if (!worksheet) {
+            stream.end();
+            return;
+        }
+        const map = options?.map || createDefaultWriteMapper(options?.dateFormat, options?.dateUTC);
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        const formatter = new CsvFormatterStream(buildFormatterOptions(options));
+        const pipelinePromise = pipeline(formatter, stream);
+        let lastRow = 1;
+        worksheet.eachRow((row, rowNumber) => {
+            if (includeEmptyRows) {
+                while (lastRow++ < rowNumber - 1) {
+                    formatter.write([]);
+                }
+            }
+            const { values } = row;
+            values.shift();
+            formatter.write(values.map(map));
+            lastRow = rowNumber;
+        });
+        formatter.end();
+        await pipelinePromise;
+    }
+    // ===========================================================================
+    // Static Factory Methods for Streaming
+    // ===========================================================================
+    /**
+     * Create a streaming workbook writer for large files.
+     * This is more memory-efficient than using Workbook for large datasets.
+     *
+     * @param options - Options for the workbook writer
+     *   - Node.js: can use { filename } or { stream }
+     *   - Browser: must use { stream }
+     * @returns A new WorkbookWriter instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with filename
+     * const writer = Workbook.createStreamWriter({ filename: "large-file.xlsx" });
+     *
+     * // Browser or Node.js with stream
+     * const writer = Workbook.createStreamWriter({ stream: writableStream });
+     *
+     * const sheet = writer.addWorksheet("Sheet1");
+     * for (let i = 0; i < 1000000; i++) {
+     *   sheet.addRow([i, `Row ${i}`]).commit();
+     * }
+     * await writer.commit();
+     * ```
+     */
+    static createStreamWriter(options) {
+        return new WorkbookWriter(options);
+    }
+    /**
+     * Create a streaming workbook reader for large files.
+     * This is more memory-efficient than using Workbook.xlsx.readFile for large datasets.
+     *
+     * @param input - File path (Node.js only) or readable stream
+     * @param options - Options for the workbook reader
+     * @returns A new WorkbookReader instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with file path
+     * const reader = Workbook.createStreamReader("large-file.xlsx");
+     *
+     * // Browser or Node.js with stream
+     * const reader = Workbook.createStreamReader(readableStream);
+     *
+     * for await (const event of reader) {
+     *   if (event.eventType === "worksheet") {
+     *     const worksheet = event.value;
+     *     for await (const row of worksheet) {
+     *       console.log(row.values);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    static createStreamReader(input, options) {
+        return new WorkbookReader(input, options);
+    }
+    // ===========================================================================
+    // Worksheet Management
+    // ===========================================================================
+    get nextId() {
+        // Find the next unique spot to add worksheet
+        for (let i = 1; i < this._worksheets.length; i++) {
+            if (!this._worksheets[i]) {
+                return i;
+            }
+        }
+        return this._worksheets.length || 1;
+    }
+    /**
+     * Add a new worksheet and return a reference to it
+     */
+    addWorksheet(name, options) {
+        const id = this.nextId;
+        const lastOrderNo = this._worksheets.reduce((acc, ws) => ((ws && ws.orderNo) > acc ? ws.orderNo : acc), 0);
+        const worksheetOptions = {
+            ...options,
+            id,
+            name,
+            orderNo: lastOrderNo + 1,
+            workbook: this
+        };
+        const worksheet = new Worksheet(worksheetOptions);
+        this._worksheets[id] = worksheet;
+        return worksheet;
+    }
+    removeWorksheetEx(worksheet) {
+        delete this._worksheets[worksheet.id];
+    }
+    removeWorksheet(id) {
+        const worksheet = this.getWorksheet(id);
+        if (worksheet) {
+            worksheet.destroy();
+        }
+    }
+    /**
+     * Fetch sheet by name or id
+     */
+    getWorksheet(id) {
+        if (id === undefined) {
+            return this._worksheets.find(Boolean);
+        }
+        if (typeof id === "number") {
+            return this._worksheets[id];
+        }
+        if (typeof id === "string") {
+            return this._worksheets.find(worksheet => worksheet && worksheet.name === id);
+        }
+        return undefined;
+    }
+    /**
+     * Return a clone of worksheets in order
+     */
+    get worksheets() {
+        return this._worksheets
+            .slice(1)
+            .sort((a, b) => a.orderNo - b.orderNo)
+            .filter(Boolean);
+    }
+    /**
+     * Iterate over all sheets.
+     *
+     * Note: `workbook.worksheets.forEach` will still work but this is better.
+     */
+    eachSheet(callback) {
+        this.worksheets.forEach(sheet => {
+            callback(sheet, sheet.id);
+        });
+    }
+    // ===========================================================================
+    // Defined Names
+    // ===========================================================================
+    get definedNames() {
+        return this._definedNames;
+    }
+    // ===========================================================================
+    // Themes
+    // ===========================================================================
+    clearThemes() {
+        // Note: themes are not an exposed feature, meddle at your peril!
+        this._themes = undefined;
+    }
+    // ===========================================================================
+    // Images
+    // ===========================================================================
+    /**
+     * Add Image to Workbook and return the id
+     */
+    addImage(image) {
+        const id = this.media.length;
+        this.media.push({ ...image, type: "image" });
+        return id;
+    }
+    getImage(id) {
+        return this.media[Number(id)];
+    }
+    // ===========================================================================
+    // Model (Serialization)
+    // ===========================================================================
+    get model() {
+        return {
+            creator: this.creator || "Unknown",
+            lastModifiedBy: this.lastModifiedBy || "Unknown",
+            lastPrinted: this.lastPrinted,
+            created: this.created,
+            modified: this.modified,
+            properties: this.properties,
+            worksheets: this.worksheets.map(worksheet => worksheet.model),
+            sheets: this.worksheets.map(ws => ws.model).filter(Boolean),
+            definedNames: this._definedNames.model,
+            views: this.views,
+            company: this.company,
+            manager: this.manager,
+            title: this.title,
+            subject: this.subject,
+            keywords: this.keywords,
+            category: this.category,
+            description: this.description,
+            language: this.language,
+            revision: this.revision,
+            contentStatus: this.contentStatus,
+            themes: this._themes,
+            media: this.media,
+            pivotTables: this.pivotTables,
+            calcProperties: this.calcProperties,
+            passthrough: this._passthrough,
+            rawDrawings: this._rawDrawings,
+            defaultFont: this._defaultFont
+        };
+    }
+    set model(value) {
+        this.creator = value.creator;
+        this.lastModifiedBy = value.lastModifiedBy;
+        this.lastPrinted = value.lastPrinted;
+        this.created = value.created;
+        this.modified = value.modified;
+        this.company = value.company;
+        this.manager = value.manager;
+        this.title = value.title;
+        this.subject = value.subject;
+        this.keywords = value.keywords;
+        this.category = value.category;
+        this.description = value.description;
+        this.language = value.language;
+        this.revision = value.revision;
+        this.contentStatus = value.contentStatus;
+        this.properties = value.properties;
+        this.calcProperties = value.calcProperties;
+        this._worksheets = [];
+        value.worksheets.forEach(worksheetModel => {
+            const { id, name, state } = worksheetModel;
+            const orderNo = value.sheets && value.sheets.findIndex(ws => ws.id === id);
+            const worksheet = (this._worksheets[id] = new Worksheet({
+                id,
+                name,
+                orderNo: orderNo !== -1 ? orderNo : undefined,
+                state,
+                workbook: this
+            }));
+            worksheet.model = worksheetModel;
+        });
+        this._definedNames.model = value.definedNames;
+        this.views = value.views;
+        this._themes = value.themes;
+        this.media = value.media || [];
+        // 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;
+    }
+}
+// ===========================================================================
+// Static Properties
+// ===========================================================================
+/**
+ * Streaming workbook writer class for large files.
+ * @example
+ * // Node.js: new Workbook.Writer({ filename: "large.xlsx" })
+ * // Browser: new Workbook.Writer({ stream: writableStream })
+ */
+Workbook.Writer = WorkbookWriter;
+/**
+ * Streaming workbook reader class for large files.
+ * @example
+ * // Node.js: new Workbook.Reader("large.xlsx")
+ * // Browser: new Workbook.Reader(readableStream)
+ */
+Workbook.Reader = WorkbookReader;
+export { Workbook };