@cj-tech-master/excelts 1.6.3-canary.20251224193747.e89b618 → 1.6.3-canary.20251226035947.ef0b4f2

package/dist/esm/utils/zip/streaming-zip.js

@@ -0,0 +1,259 @@
+/**
+ * Streaming ZIP creator - fflate-compatible API
+ *
+ * This module provides a streaming ZIP API compatible with fflate's Zip/ZipDeflate,
+ * but uses native zlib compression for better performance.
+ *
+ * Usage:
+ * ```ts
+ * const zip = new StreamingZip((err, data, final) => {
+ *   if (err) handleError(err);
+ *   else {
+ *     stream.write(data);
+ *     if (final) stream.end();
+ *   }
+ * });
+ *
+ * const file = new ZipDeflateFile("path/file.txt", { level: 6 });
+ * zip.add(file);
+ * file.push(data1);
+ * file.push(data2, true); // true = final chunk
+ *
+ * zip.end();
+ * ```
+ */
+import { crc32 } from "./crc32.js";
+import { compressSync } from "./compress.js";
+// ZIP signature constants
+const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+// ZIP version constants
+const VERSION_NEEDED = 20; // 2.0 - supports DEFLATE
+const VERSION_MADE_BY = 20; // 2.0
+// Compression methods
+const COMPRESSION_STORE = 0;
+const COMPRESSION_DEFLATE = 8;
+const encoder = new TextEncoder();
+/**
+ * Convert Date to DOS time format
+ */
+function dateToDos(date) {
+    const dosTime = ((date.getHours() & 0x1f) << 11) |
+        ((date.getMinutes() & 0x3f) << 5) |
+        ((date.getSeconds() >> 1) & 0x1f);
+    const dosDate = (((date.getFullYear() - 1980) & 0x7f) << 9) |
+        (((date.getMonth() + 1) & 0x0f) << 5) |
+        (date.getDate() & 0x1f);
+    return [dosTime, dosDate];
+}
+/**
+ * ZipDeflate-compatible file stream
+ * Collects data chunks, compresses on finalization
+ */
+export class ZipDeflateFile {
+    constructor(name, options) {
+        this.chunks = [];
+        this.totalSize = 0;
+        this.finalized = false;
+        this._ondata = null;
+        this.name = name;
+        this.level = options?.level ?? 6;
+    }
+    /**
+     * Set data callback (called by StreamingZip)
+     */
+    set ondata(cb) {
+        this._ondata = cb;
+    }
+    /**
+     * Push data to the file
+     * @param data - Data chunk
+     * @param final - Whether this is the final chunk
+     */
+    push(data, final = false) {
+        if (this.finalized) {
+            throw new Error("Cannot push to finalized ZipDeflateFile");
+        }
+        if (data.length > 0) {
+            this.chunks.push(data);
+            this.totalSize += data.length;
+        }
+        if (final) {
+            this.finalized = true;
+            this._flush();
+        }
+    }
+    /**
+     * Flush collected data through compression and emit
+     */
+    _flush() {
+        if (!this._ondata) {
+            return;
+        }
+        // Combine chunks
+        let uncompressed;
+        if (this.chunks.length === 0) {
+            uncompressed = new Uint8Array(0);
+        }
+        else if (this.chunks.length === 1) {
+            uncompressed = this.chunks[0];
+        }
+        else {
+            uncompressed = new Uint8Array(this.totalSize);
+            let offset = 0;
+            for (const chunk of this.chunks) {
+                uncompressed.set(chunk, offset);
+                offset += chunk.length;
+            }
+        }
+        // Compress if level > 0 and data is not empty
+        const shouldCompress = this.level > 0 && uncompressed.length > 0;
+        const compressed = shouldCompress
+            ? compressSync(uncompressed, { level: this.level })
+            : uncompressed;
+        // Build local file header + data
+        const nameBytes = encoder.encode(this.name);
+        const crcValue = crc32(uncompressed);
+        const [dosTime, dosDate] = dateToDos(new Date());
+        // Local file header (30 bytes + filename)
+        const header = new Uint8Array(30 + nameBytes.length);
+        const view = new DataView(header.buffer);
+        view.setUint32(0, LOCAL_FILE_HEADER_SIG, true);
+        view.setUint16(4, VERSION_NEEDED, true);
+        view.setUint16(6, 0x0800, true); // UTF-8 flag
+        view.setUint16(8, shouldCompress ? COMPRESSION_DEFLATE : COMPRESSION_STORE, true);
+        view.setUint16(10, dosTime, true);
+        view.setUint16(12, dosDate, true);
+        view.setUint32(14, crcValue, true);
+        view.setUint32(18, compressed.length, true);
+        view.setUint32(22, uncompressed.length, true);
+        view.setUint16(26, nameBytes.length, true);
+        view.setUint16(28, 0, true); // Extra field length
+        header.set(nameBytes, 30);
+        // Store info for central directory BEFORE emitting data
+        // (StreamingZip reads this in the final callback)
+        this._entryInfo = {
+            name: nameBytes,
+            crc: crcValue,
+            compressedSize: compressed.length,
+            uncompressedSize: uncompressed.length,
+            compressionMethod: shouldCompress ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            dosTime,
+            dosDate,
+            offset: -1 // Will be set by StreamingZip
+        };
+        // Emit header
+        this._ondata(header, false);
+        // Emit compressed data (final chunk)
+        this._ondata(compressed, true);
+        // Clear chunks for GC
+        this.chunks.length = 0;
+    }
+    /**
+     * Get entry info (called by StreamingZip after finalization)
+     */
+    getEntryInfo() {
+        return this._entryInfo || null;
+    }
+}
+/**
+ * Streaming ZIP - fflate Zip-compatible API
+ * Creates ZIP files in a streaming manner
+ */
+export class StreamingZip {
+    /**
+     * Create a streaming ZIP
+     * @param callback - Called with (err, data, final) as data becomes available
+     */
+    constructor(callback) {
+        this.entries = [];
+        this.currentOffset = 0;
+        this.ended = false;
+        this.callback = callback;
+    }
+    /**
+     * Add a file to the ZIP
+     * @param file - ZipDeflateFile instance
+     */
+    add(file) {
+        if (this.ended) {
+            throw new Error("Cannot add files after calling end()");
+        }
+        // Capture offset when first data is written, not when add() is called
+        // This is important because streaming files may have data pushed later
+        let startOffset = -1;
+        file.ondata = (data, final) => {
+            // Capture offset on first data chunk
+            if (startOffset === -1) {
+                startOffset = this.currentOffset;
+            }
+            this.currentOffset += data.length;
+            this.callback(null, data, false);
+            if (final) {
+                // Get entry info and set offset
+                const entryInfo = file.getEntryInfo();
+                if (entryInfo) {
+                    entryInfo.offset = startOffset;
+                    this.entries.push(entryInfo);
+                }
+            }
+        };
+    }
+    /**
+     * Finalize the ZIP
+     * Writes central directory and end-of-central-directory record
+     */
+    end() {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        const centralDirOffset = this.currentOffset;
+        const centralDirChunks = [];
+        // Build central directory headers
+        for (const entry of this.entries) {
+            const header = new Uint8Array(46 + entry.name.length);
+            const view = new DataView(header.buffer);
+            view.setUint32(0, CENTRAL_DIR_HEADER_SIG, true);
+            view.setUint16(4, VERSION_MADE_BY, true);
+            view.setUint16(6, VERSION_NEEDED, true);
+            view.setUint16(8, 0x0800, true); // UTF-8 flag
+            view.setUint16(10, entry.compressionMethod, true);
+            view.setUint16(12, entry.dosTime, true);
+            view.setUint16(14, entry.dosDate, true);
+            view.setUint32(16, entry.crc, true);
+            view.setUint32(20, entry.compressedSize, true);
+            view.setUint32(24, entry.uncompressedSize, true);
+            view.setUint16(28, entry.name.length, true);
+            view.setUint16(30, 0, true); // Extra field length
+            view.setUint16(32, 0, true); // Comment length
+            view.setUint16(34, 0, true); // Disk number start
+            view.setUint16(36, 0, true); // Internal file attributes
+            view.setUint32(38, 0, true); // External file attributes
+            view.setUint32(42, entry.offset, true);
+            header.set(entry.name, 46);
+            centralDirChunks.push(header);
+        }
+        // Emit central directory
+        for (const chunk of centralDirChunks) {
+            this.callback(null, chunk, false);
+        }
+        const centralDirSize = centralDirChunks.reduce((sum, c) => sum + c.length, 0);
+        // Build end of central directory
+        const eocd = new Uint8Array(22);
+        const eocdView = new DataView(eocd.buffer);
+        eocdView.setUint32(0, END_OF_CENTRAL_DIR_SIG, true);
+        eocdView.setUint16(4, 0, true); // Disk number
+        eocdView.setUint16(6, 0, true); // Disk with central dir
+        eocdView.setUint16(8, this.entries.length, true);
+        eocdView.setUint16(10, this.entries.length, true);
+        eocdView.setUint32(12, centralDirSize, true);
+        eocdView.setUint32(16, centralDirOffset, true);
+        eocdView.setUint16(20, 0, true); // Comment length
+        // Emit end of central directory (final chunk)
+        this.callback(null, eocd, true);
+    }
+}
+// Export aliases for fflate compatibility
+export { StreamingZip as Zip, ZipDeflateFile as ZipDeflate };

package/dist/esm/xlsx/xform/sheet/col-breaks-xform.js

@@ -0,0 +1,35 @@
+import { PageBreaksXform } from "./page-breaks-xform.js";
+import { ListXform } from "../list-xform.js";
+/**
+ * Xform for column page breaks (colBreaks element in worksheet XML)
+ * Used to define manual page breaks between columns when printing.
+ *
+ * XML structure:
+ * <colBreaks count="3" manualBreakCount="3">
+ *   <brk id="3" max="1048575" man="1"/>
+ *   <brk id="6" max="1048575" man="1"/>
+ * </colBreaks>
+ */
+class ColBreaksXform extends ListXform {
+    constructor() {
+        super({
+            tag: "colBreaks",
+            count: true,
+            childXform: new PageBreaksXform()
+        });
+    }
+    // Override to add manualBreakCount attribute required by Excel
+    render(xmlStream, model) {
+        if (model && model.length) {
+            xmlStream.openNode(this.tag, this.$);
+            xmlStream.addAttribute(this.$count, model.length);
+            xmlStream.addAttribute("manualBreakCount", model.length);
+            const { childXform } = this;
+            for (const childModel of model) {
+                childXform.render(xmlStream, childModel);
+            }
+            xmlStream.closeNode();
+        }
+    }
+}
+export { ColBreaksXform };

package/dist/esm/xlsx/xform/sheet/page-breaks-xform.js

@@ -1,4 +1,8 @@
 import { BaseXform } from "../base-xform.js";
+/**
+ * Xform for individual page break (brk element)
+ * Used by both RowBreaksXform and ColBreaksXform
+ */
 class PageBreaksXform extends BaseXform {
     get tag() {
         return "brk";
@@ -8,7 +12,15 @@ class PageBreaksXform extends BaseXform {
     }
     parseOpen(node) {
         if (node.name === "brk") {
-            this.model = node.attributes.ref;
+            const { id, max, man, min } = node.attributes;
+            this.model = {
+                id: +id,
+                max: +max,
+                man: +man
+            };
+            if (min !== undefined) {
+                this.model.min = +min;
+            }
             return true;
         }
         return false;

package/dist/esm/xlsx/xform/sheet/row-breaks-xform.js

@@ -1,31 +1,29 @@
 import { PageBreaksXform } from "./page-breaks-xform.js";
 import { ListXform } from "../list-xform.js";
+/**
+ * Xform for row page breaks (rowBreaks element in worksheet XML)
+ * Used to define manual page breaks between rows when printing.
+ */
 class RowBreaksXform extends ListXform {
     constructor() {
-        const options = {
+        super({
             tag: "rowBreaks",
             count: true,
             childXform: new PageBreaksXform()
-        };
-        super(options);
+        });
     }
-    // get tag() { return 'rowBreaks'; }
+    // Override to add manualBreakCount attribute required by Excel
     render(xmlStream, model) {
         if (model && model.length) {
             xmlStream.openNode(this.tag, this.$);
-            if (this.count) {
-                xmlStream.addAttribute(this.$count, model.length);
-                xmlStream.addAttribute("manualBreakCount", model.length);
-            }
+            xmlStream.addAttribute(this.$count, model.length);
+            xmlStream.addAttribute("manualBreakCount", model.length);
             const { childXform } = this;
-            model.forEach((childModel) => {
+            for (const childModel of model) {
                 childXform.render(xmlStream, childModel);
-            });
+            }
             xmlStream.closeNode();
         }
-        else if (this.empty) {
-            xmlStream.leafNode(this.tag);
-        }
     }
 }
 export { RowBreaksXform };

package/dist/esm/xlsx/xform/sheet/worksheet-xform.js

@@ -22,6 +22,7 @@ import { PictureXform } from "./picture-xform.js";
 import { DrawingXform } from "./drawing-xform.js";
 import { TablePartXform } from "./table-part-xform.js";
 import { RowBreaksXform } from "./row-breaks-xform.js";
+import { ColBreaksXform } from "./col-breaks-xform.js";
 import { HeaderFooterXform } from "./header-footer-xform.js";
 import { ConditionalFormattingsXform } from "./cf/conditional-formattings-xform.js";
 import { ExtLstXform } from "./ext-lst-xform.js";
@@ -108,6 +109,7 @@ class WorkSheetXform extends BaseXform {
                 childXform: new MergeCellXform()
             }),
             rowBreaks: new RowBreaksXform(),
+            colBreaks: new ColBreaksXform(),
             hyperlinks: new ListXform({
                 tag: "hyperlinks",
                 count: false,
@@ -324,7 +326,8 @@ class WorkSheetXform extends BaseXform {
         this.map.pageSetup.render(xmlStream, model.pageSetup);
         this.map.headerFooter.render(xmlStream, model.headerFooter);
         this.map.rowBreaks.render(xmlStream, model.rowBreaks);
-        this.map.drawing.render(xmlStream, model.drawing); // Note: must be after rowBreaks
+        this.map.colBreaks.render(xmlStream, model.colBreaks);
+        this.map.drawing.render(xmlStream, model.drawing); // Note: must be after rowBreaks/colBreaks
         this.map.picture.render(xmlStream, model.background); // Note: must be after drawing
         this.map.tableParts.render(xmlStream, model.tables);
         this.map.extLst.render(xmlStream, model);
@@ -399,7 +402,9 @@ class WorkSheetXform extends BaseXform {
                     background: this.map.picture.model,
                     drawing: this.map.drawing.model,
                     tables: this.map.tableParts.model,
-                    conditionalFormattings
+                    conditionalFormattings,
+                    rowBreaks: this.map.rowBreaks.model || [],
+                    colBreaks: this.map.colBreaks.model || []
                 };
                 if (this.map.autoFilter.model) {
                     this.model.autoFilter = this.map.autoFilter.model;

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

@@ -9,7 +9,7 @@
  * - readFile/writeFile (no file system)
  * - read/write (no streams)
  */
-import { Unzip, UnzipInflate } from "fflate";
+import { ZipParser } from "../utils/unzip/zip-parser.js";
 import { ZipWriter } from "../utils/zip-stream.browser.js";
 import { StreamBuf } from "../utils/stream-buf.browser.js";
 import { bufferToString } from "../utils/utils.js";
@@ -99,58 +99,15 @@ class XLSX extends XLSXBase {
         else {
             buffer = new Uint8Array(data);
         }
-        const allFiles = {};
-        await new Promise((resolve, reject) => {
-            let filesProcessed = 0;
-            let zipEnded = false;
-            let filesStarted = 0;
-            const checkCompletion = () => {
-                if (zipEnded && filesProcessed === filesStarted) {
-                    resolve();
-                }
-            };
-            const unzipper = new Unzip((file) => {
-                filesStarted++;
-                const fileChunks = [];
-                let totalLength = 0;
-                file.ondata = (err, fileData, final) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    if (fileData) {
-                        fileChunks.push(fileData);
-                        totalLength += fileData.length;
-                    }
-                    if (final) {
-                        if (fileChunks.length === 1) {
-                            allFiles[file.name] = fileChunks[0];
-                        }
-                        else if (fileChunks.length > 1) {
-                            const fullData = new Uint8Array(totalLength);
-                            let offset = 0;
-                            for (const chunk of fileChunks) {
-                                fullData.set(chunk, offset);
-                                offset += chunk.length;
-                            }
-                            allFiles[file.name] = fullData;
-                        }
-                        else {
-                            allFiles[file.name] = new Uint8Array(0);
-                        }
-                        filesProcessed++;
-                        fileChunks.length = 0;
-                        checkCompletion();
-                    }
-                };
-                file.start();
-            });
-            unzipper.register(UnzipInflate);
-            unzipper.push(buffer, true);
-            zipEnded = true;
-            checkCompletion();
-        });
-        return this.loadFromFiles(allFiles, options);
+        // Use native ZipParser for extraction
+        const parser = new ZipParser(buffer);
+        const allFiles = await parser.extractAll();
+        // Convert Map to Record for loadFromFiles
+        const filesRecord = {};
+        for (const [path, content] of allFiles) {
+            filesRecord[path] = content;
+        }
+        return this.loadFromFiles(filesRecord, options);
     }
     /**
      * Write workbook to buffer

package/dist/esm/xlsx/xlsx.js

@@ -10,8 +10,8 @@
  * - writeBuffer: Write to buffer
  */
 import fs from "fs";
-import { Unzip, UnzipInflate } from "fflate";
 import { PassThrough } from "stream";
+import { ZipParser } from "../utils/unzip/zip-parser.js";
 import { ZipWriter } from "../utils/zip-stream.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { fileExists, bufferToString } from "../utils/utils.js";
@@ -100,76 +100,44 @@ class XLSX extends XLSXBase {
     // Node.js specific: Stream operations
     // ===========================================================================
     async read(stream, options) {
-        const allFiles = {};
+        // Collect all stream data into a single buffer
+        const chunks = [];
         await new Promise((resolve, reject) => {
-            let filesProcessed = 0;
-            let zipEnded = false;
-            let filesStarted = 0;
-            const cleanup = () => {
-                stream.removeListener("data", onData);
-                stream.removeListener("end", onEnd);
-                stream.removeListener("error", onError);
-            };
-            const checkCompletion = () => {
-                if (zipEnded && filesProcessed === filesStarted) {
-                    cleanup();
-                    resolve();
-                }
-            };
-            const unzipper = new Unzip((file) => {
-                filesStarted++;
-                const fileChunks = [];
-                let totalLength = 0;
-                file.ondata = (err, data, final) => {
-                    if (err) {
-                        cleanup();
-                        reject(err);
-                        return;
-                    }
-                    if (data) {
-                        fileChunks.push(data);
-                        totalLength += data.length;
-                    }
-                    if (final) {
-                        if (fileChunks.length === 1) {
-                            allFiles[file.name] = fileChunks[0];
-                        }
-                        else if (fileChunks.length > 1) {
-                            const fullData = new Uint8Array(totalLength);
-                            let offset = 0;
-                            for (const chunk of fileChunks) {
-                                fullData.set(chunk, offset);
-                                offset += chunk.length;
-                            }
-                            allFiles[file.name] = fullData;
-                        }
-                        else {
-                            allFiles[file.name] = new Uint8Array(0);
-                        }
-                        filesProcessed++;
-                        fileChunks.length = 0;
-                        checkCompletion();
-                    }
-                };
-                file.start();
-            });
-            unzipper.register(UnzipInflate);
             const onData = (chunk) => {
-                unzipper.push(chunk);
+                chunks.push(chunk);
             };
             const onEnd = () => {
-                unzipper.push(new Uint8Array(0), true);
-                zipEnded = true;
-                checkCompletion();
+                stream.removeListener("data", onData);
+                stream.removeListener("end", onEnd);
+                stream.removeListener("error", onError);
+                resolve();
             };
             const onError = (err) => {
-                cleanup();
+                stream.removeListener("data", onData);
+                stream.removeListener("end", onEnd);
+                stream.removeListener("error", onError);
                 reject(err);
             };
             stream.on("data", onData);
             stream.on("end", onEnd);
             stream.on("error", onError);
         });
+        // Combine chunks into a single buffer
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const buffer = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            buffer.set(chunk, offset);
+            offset += chunk.length;
+        }
+        // Use native ZipParser for extraction
+        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);
     }
     async write(stream, options) {

package/dist/types/csv/csv-core.d.ts

@@ -4,7 +4,7 @@
  * A lightweight, cross-platform CSV implementation that works in both
  * Node.js and Browser environments with zero dependencies.
  *
- * Compatible with fast-csv API for drop-in replacement.
+ * High-performance RFC 4180 compliant CSV parser and formatter.
  *
  * @see https://tools.ietf.org/html/rfc4180
  */
@@ -31,7 +31,7 @@ export interface RowValidationResult<T = Row> {
     reason?: string;
 }
 /**
- * CSV parsing options - compatible with fast-csv
+ * CSV parsing options
  */
 export interface CsvParseOptions {
     /** Field delimiter (default: ",") */
@@ -40,9 +40,9 @@ export interface CsvParseOptions {
     quote?: string | false | null;
     /** Escape character for quotes (default: '"'), set to false or null to disable */
     escape?: string | false | null;
-    /** Skip empty lines (default: false) - same as fast-csv ignoreEmpty */
+    /** Skip empty lines (default: false) */
     skipEmptyLines?: boolean;
-    /** Alias for skipEmptyLines for fast-csv compatibility */
+    /** Alias for skipEmptyLines */
     ignoreEmpty?: boolean;
     /** Trim whitespace from both sides of fields (default: false) */
     trim?: boolean;
@@ -124,7 +124,7 @@ export interface CsvParseOptions {
     };
 }
 /**
- * CSV formatting options - compatible with fast-csv
+ * CSV formatting options
  */
 export interface CsvFormatOptions {
     /** Field delimiter (default: ",") */
@@ -133,7 +133,7 @@ export interface CsvFormatOptions {
     quote?: string | false | null;
     /** Escape character (default: same as quote) */
     escape?: string | false | null;
-    /** Row delimiter (default: "\n" for fast-csv compatibility) */
+    /** Row delimiter (default: "\n") */
     rowDelimiter?: string;
     /** Always quote all fields (default: false, only quote when necessary) */
     alwaysQuote?: boolean;

package/dist/types/csv/csv.base.d.ts

@@ -2,8 +2,9 @@
  * CSV Base class - Shared functionality for Node.js and Browser
  *
  * Uses native CSV parser (RFC 4180 compliant) with zero external dependencies.
- * Date parsing uses dayjs for format flexibility.
+ * Date parsing uses native high-performance datetime utilities.
  */
+import { type DateFormat } from "../utils/datetime";
 import { type CsvParseOptions, type CsvFormatOptions } from "./csv-core";
 import type { Workbook } from "../doc/workbook";
 import type { Worksheet } from "../doc/worksheet";
@@ -12,7 +13,7 @@ import type { Worksheet } from "../doc/worksheet";
  */
 export interface CsvReadOptions {
     /** Date format strings to try when parsing (default: ISO formats) */
-    dateFormats?: string[];
+    dateFormats?: readonly DateFormat[];
     /** Custom value mapper function */
     map?(value: any, index: number): any;
     /** Worksheet name to create (default: "Sheet1") */
@@ -44,7 +45,7 @@ export interface CsvWriteOptions {
 /**
  * Create the default value mapper for CSV parsing
  */
-export declare function createDefaultValueMapper(dateFormats: string[]): (datum: any) => any;
+export declare function createDefaultValueMapper(dateFormats: readonly DateFormat[]): (datum: any) => any;
 /**
  * Create the default value mapper for CSV writing
  */

package/dist/types/doc/column.d.ts

@@ -97,6 +97,12 @@ declare class Column {
      */
     get values(): CellValueType[];
     set values(v: CellValueType[]);
+    /**
+     * Add a page break after this column.
+     * @param top - Optional top row limit for the page break (1-indexed)
+     * @param bottom - Optional bottom row limit for the page break (1-indexed)
+     */
+    addPageBreak(top?: number, bottom?: number): void;
     get numFmt(): string | NumFmt | undefined;
     set numFmt(value: string | undefined);
     get font(): Partial<Font> | undefined;