@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

package/dist/browser/modules/archive/zip-parser.js

@@ -0,0 +1,332 @@
+/**
+ * Pure Uint8Array-based ZIP parser
+ * Works in both Node.js and browser environments
+ * No dependency on Node.js stream module
+ */
+import { decompress, decompressSync } from "./compress.browser.js";
+import { BinaryReader } from "./utils/binary.js";
+import { resolveZipLastModifiedDateFromUnixSeconds } from "./utils/timestamps.js";
+import { parseZipExtraFields } from "./utils/zip-extra-fields.js";
+import { CENTRAL_DIR_HEADER_SIG, COMPRESSION_DEFLATE, COMPRESSION_STORE, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG, UINT16_MAX, UINT32_MAX, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG, ZIP64_END_OF_CENTRAL_DIR_SIG } from "./zip-constants.js";
+/**
+ * Find the End of Central Directory record
+ * Searches backwards from the end of the file
+ */
+function findEndOfCentralDir(data) {
+    // EOCD is at least 22 bytes, search backwards
+    // Comment can be up to 65535 bytes
+    const minOffset = Math.max(0, data.length - 65557);
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    for (let i = data.length - 22; i >= minOffset; i--) {
+        if (view.getUint32(i, true) === END_OF_CENTRAL_DIR_SIG) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Find ZIP64 End of Central Directory Locator
+ */
+function findZip64EOCDLocator(data, eocdOffset) {
+    // ZIP64 EOCD Locator is 20 bytes and appears right before EOCD
+    const locatorOffset = eocdOffset - 20;
+    if (locatorOffset < 0) {
+        return -1;
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (view.getUint32(locatorOffset, true) === ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) {
+        return locatorOffset;
+    }
+    return -1;
+}
+/**
+ * Parse ZIP file entries from Central Directory
+ */
+function parseZipEntries(data, options = {}) {
+    const { decodeStrings = true } = options;
+    const entries = [];
+    // Find End of Central Directory
+    const eocdOffset = findEndOfCentralDir(data);
+    if (eocdOffset === -1) {
+        throw new Error("Invalid ZIP file: End of Central Directory not found");
+    }
+    const reader = new BinaryReader(data, eocdOffset);
+    // Read EOCD
+    // Offset  Size  Description
+    // 0       4     EOCD signature (0x06054b50)
+    // 4       2     Number of this disk
+    // 6       2     Disk where central directory starts
+    // 8       2     Number of central directory records on this disk
+    // 10      2     Total number of central directory records
+    // 12      4     Size of central directory (bytes)
+    // 16      4     Offset of start of central directory
+    // 20      2     Comment length
+    reader.skip(4); // signature
+    reader.skip(2); // disk number
+    reader.skip(2); // disk where central dir starts
+    reader.skip(2); // entries on this disk
+    let totalEntries = reader.readUint16(); // total entries
+    reader.skip(4); // central directory size (unused)
+    let centralDirOffset = reader.readUint32();
+    // Check for ZIP64
+    const zip64LocatorOffset = findZip64EOCDLocator(data, eocdOffset);
+    if (zip64LocatorOffset !== -1) {
+        const locatorReader = new BinaryReader(data, zip64LocatorOffset);
+        locatorReader.skip(4); // signature
+        locatorReader.skip(4); // disk number with ZIP64 EOCD
+        const zip64EOCDOffset = Number(locatorReader.readBigUint64());
+        // Read ZIP64 EOCD
+        const zip64Reader = new BinaryReader(data, zip64EOCDOffset);
+        const zip64Sig = zip64Reader.readUint32();
+        if (zip64Sig === ZIP64_END_OF_CENTRAL_DIR_SIG) {
+            zip64Reader.skip(8); // size of ZIP64 EOCD
+            zip64Reader.skip(2); // version made by
+            zip64Reader.skip(2); // version needed
+            zip64Reader.skip(4); // disk number
+            zip64Reader.skip(4); // disk with central dir
+            const zip64TotalEntries = Number(zip64Reader.readBigUint64());
+            zip64Reader.skip(8); // central directory size (unused)
+            const zip64CentralDirOffset = Number(zip64Reader.readBigUint64());
+            // Use ZIP64 values if standard values are maxed out
+            if (totalEntries === UINT16_MAX) {
+                totalEntries = zip64TotalEntries;
+            }
+            if (centralDirOffset === UINT32_MAX) {
+                centralDirOffset = zip64CentralDirOffset;
+            }
+        }
+    }
+    // Read Central Directory entries
+    const centralReader = new BinaryReader(data, centralDirOffset);
+    for (let i = 0; i < totalEntries; i++) {
+        const sig = centralReader.readUint32();
+        if (sig !== CENTRAL_DIR_HEADER_SIG) {
+            throw new Error(`Invalid Central Directory header signature at entry ${i}`);
+        }
+        // Central Directory File Header format:
+        // Offset  Size  Description
+        // 0       4     Central directory file header signature (0x02014b50)
+        // 4       2     Version made by
+        // 6       2     Version needed to extract
+        // 8       2     General purpose bit flag
+        // 10      2     Compression method
+        // 12      2     File last modification time
+        // 14      2     File last modification date
+        // 16      4     CRC-32
+        // 20      4     Compressed size
+        // 24      4     Uncompressed size
+        // 28      2     File name length
+        // 30      2     Extra field length
+        // 32      2     File comment length
+        // 34      2     Disk number where file starts
+        // 36      2     Internal file attributes
+        // 38      4     External file attributes
+        // 42      4     Relative offset of local file header
+        // 46      n     File name
+        // 46+n    m     Extra field
+        // 46+n+m  k     File comment
+        centralReader.skip(2); // version made by
+        centralReader.skip(2); // version needed
+        const flags = centralReader.readUint16();
+        const compressionMethod = centralReader.readUint16();
+        const lastModTime = centralReader.readUint16();
+        const lastModDate = centralReader.readUint16();
+        const crc32 = centralReader.readUint32();
+        let compressedSize = centralReader.readUint32();
+        let uncompressedSize = centralReader.readUint32();
+        const fileNameLength = centralReader.readUint16();
+        const extraFieldLength = centralReader.readUint16();
+        const commentLength = centralReader.readUint16();
+        centralReader.skip(2); // disk number start
+        centralReader.skip(2); // internal attributes
+        const externalAttributes = centralReader.readUint32();
+        let localHeaderOffset = centralReader.readUint32();
+        // Check for UTF-8 flag (bit 11)
+        const isUtf8 = (flags & 0x800) !== 0;
+        const useUtf8 = decodeStrings && isUtf8;
+        const fileName = centralReader.readString(fileNameLength, useUtf8);
+        const extraField = centralReader.readBytes(extraFieldLength);
+        const comment = centralReader.readString(commentLength, useUtf8);
+        const vars = {
+            compressedSize,
+            uncompressedSize,
+            offsetToLocalFileHeader: localHeaderOffset
+        };
+        const extraFields = extraFieldLength > 0 ? parseZipExtraFields(extraField, vars) : {};
+        compressedSize = vars.compressedSize;
+        uncompressedSize = vars.uncompressedSize;
+        localHeaderOffset = vars.offsetToLocalFileHeader ?? localHeaderOffset;
+        const isDirectory = fileName.endsWith("/") || (externalAttributes & 0x10) !== 0;
+        const isEncrypted = (flags & 0x01) !== 0;
+        const unixSecondsMtime = extraFields.mtimeUnixSeconds;
+        const lastModified = resolveZipLastModifiedDateFromUnixSeconds(lastModDate, lastModTime, unixSecondsMtime);
+        entries.push({
+            path: fileName,
+            isDirectory,
+            compressedSize,
+            uncompressedSize,
+            compressionMethod,
+            crc32,
+            lastModified,
+            localHeaderOffset,
+            comment,
+            externalAttributes,
+            isEncrypted
+        });
+    }
+    return entries;
+}
+/**
+ * Extract file data for a specific entry
+ */
+async function extractEntryData(data, entry) {
+    if (entry.isDirectory) {
+        return new Uint8Array(0);
+    }
+    if (entry.isEncrypted) {
+        throw new Error(`File "${entry.path}" is encrypted and cannot be extracted`);
+    }
+    const compressedData = readEntryCompressedData(data, entry);
+    if (entry.compressionMethod === COMPRESSION_STORE) {
+        return compressedData;
+    }
+    if (entry.compressionMethod === COMPRESSION_DEFLATE) {
+        return decompress(compressedData);
+    }
+    throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);
+}
+/**
+ * Extract file data synchronously
+ */
+function extractEntryDataSync(data, entry) {
+    if (entry.isDirectory) {
+        return new Uint8Array(0);
+    }
+    if (entry.isEncrypted) {
+        throw new Error(`File "${entry.path}" is encrypted and cannot be extracted`);
+    }
+    const compressedData = readEntryCompressedData(data, entry);
+    if (entry.compressionMethod === COMPRESSION_STORE) {
+        return compressedData;
+    }
+    if (entry.compressionMethod === COMPRESSION_DEFLATE) {
+        return decompressSync(compressedData);
+    }
+    throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);
+}
+function readEntryCompressedData(data, entry) {
+    const reader = new BinaryReader(data, entry.localHeaderOffset);
+    const sig = reader.readUint32();
+    if (sig !== LOCAL_FILE_HEADER_SIG) {
+        throw new Error(`Invalid local file header signature for "${entry.path}"`);
+    }
+    reader.skip(2); // version needed
+    reader.skip(2); // flags
+    reader.skip(2); // compression method
+    reader.skip(2); // last mod time
+    reader.skip(2); // last mod date
+    reader.skip(4); // crc32
+    reader.skip(4); // compressed size
+    reader.skip(4); // uncompressed size
+    const fileNameLength = reader.readUint16();
+    const extraFieldLength = reader.readUint16();
+    reader.skip(fileNameLength);
+    reader.skip(extraFieldLength);
+    return reader.readBytes(entry.compressedSize);
+}
+/**
+ * High-level ZIP parser class
+ */
+export class ZipParser {
+    constructor(data, options = {}) {
+        this.data = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+        this.entries = parseZipEntries(this.data, options);
+        this.entryMap = new Map(this.entries.map(e => [e.path, e]));
+    }
+    /**
+     * Get all entries in the ZIP file
+     */
+    getEntries() {
+        return this.entries;
+    }
+    /**
+     * Get entry by path
+     */
+    getEntry(path) {
+        return this.entryMap.get(path);
+    }
+    /**
+     * Check if entry exists
+     */
+    hasEntry(path) {
+        return this.entryMap.has(path);
+    }
+    /**
+     * List all file paths
+     */
+    listFiles() {
+        return this.entries.map(e => e.path);
+    }
+    /**
+     * Extract a single file (async)
+     */
+    async extract(path) {
+        const entry = this.entryMap.get(path);
+        if (!entry) {
+            return null;
+        }
+        return extractEntryData(this.data, entry);
+    }
+    /**
+     * Extract a single file (sync)
+     *
+     * This is supported in both Node.js and browser builds.
+     */
+    extractSync(path) {
+        const entry = this.entryMap.get(path);
+        if (!entry) {
+            return null;
+        }
+        return extractEntryDataSync(this.data, entry);
+    }
+    /**
+     * Extract all files (async)
+     */
+    async extractAll() {
+        const result = new Map();
+        for (const entry of this.entries) {
+            const data = await extractEntryData(this.data, entry);
+            result.set(entry.path, data);
+        }
+        return result;
+    }
+    /**
+     * Extract all files (sync)
+     * Returns object with file paths as keys and Uint8Array content as values
+     */
+    extractAllSync() {
+        const result = {};
+        for (const entry of this.entries) {
+            result[entry.path] = extractEntryDataSync(this.data, entry);
+        }
+        return result;
+    }
+    /**
+     * Iterate over entries with async callback
+     */
+    async forEach(callback) {
+        for (const entry of this.entries) {
+            let dataPromise = null;
+            const getData = () => {
+                if (!dataPromise) {
+                    dataPromise = extractEntryData(this.data, entry);
+                }
+                return dataPromise;
+            };
+            const shouldContinue = await callback(entry, getData);
+            if (shouldContinue === false) {
+                break;
+            }
+        }
+    }
+}

package/dist/browser/modules/archive/zip-records.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ZIP record builders (PKWARE APPNOTE)
+ *
+ * Shared by streaming zip writer and buffer zip builder.
+ */
+export interface ZipLocalFileHeaderInput {
+    fileName: Uint8Array;
+    extraField: Uint8Array;
+    flags: number;
+    compressionMethod: number;
+    dosTime: number;
+    dosDate: number;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    versionNeeded?: number;
+}
+export declare function buildLocalFileHeader(input: ZipLocalFileHeaderInput): Uint8Array;
+export interface ZipCentralDirectoryHeaderInput {
+    fileName: Uint8Array;
+    extraField: Uint8Array;
+    comment: Uint8Array;
+    flags: number;
+    compressionMethod: number;
+    dosTime: number;
+    dosDate: number;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    localHeaderOffset: number;
+    versionMadeBy?: number;
+    versionNeeded?: number;
+    externalAttributes?: number;
+}
+export declare function buildCentralDirectoryHeader(input: ZipCentralDirectoryHeaderInput): Uint8Array;
+export interface ZipEndOfCentralDirectoryInput {
+    entryCount: number;
+    centralDirSize: number;
+    centralDirOffset: number;
+    comment: Uint8Array;
+}
+export declare function buildEndOfCentralDirectory(input: ZipEndOfCentralDirectoryInput): Uint8Array;
+export declare function buildDataDescriptor(crc32: number, compressedSize: number, uncompressedSize: number): Uint8Array<ArrayBuffer>;

package/dist/browser/modules/archive/zip-records.js

@@ -0,0 +1,84 @@
+/**
+ * ZIP record builders (PKWARE APPNOTE)
+ *
+ * Shared by streaming zip writer and buffer zip builder.
+ */
+import { CENTRAL_DIR_HEADER_SIG, DATA_DESCRIPTOR_SIG, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG, VERSION_MADE_BY, VERSION_NEEDED } from "./zip-constants.js";
+export function buildLocalFileHeader(input) {
+    const versionNeeded = input.versionNeeded ?? VERSION_NEEDED;
+    const header = new Uint8Array(30 + input.fileName.length + input.extraField.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, LOCAL_FILE_HEADER_SIG, true);
+    view.setUint16(4, versionNeeded, true);
+    view.setUint16(6, input.flags, true);
+    view.setUint16(8, input.compressionMethod, true);
+    view.setUint16(10, input.dosTime, true);
+    view.setUint16(12, input.dosDate, true);
+    view.setUint32(14, input.crc32, true);
+    view.setUint32(18, input.compressedSize, true);
+    view.setUint32(22, input.uncompressedSize, true);
+    view.setUint16(26, input.fileName.length, true);
+    view.setUint16(28, input.extraField.length, true);
+    header.set(input.fileName, 30);
+    if (input.extraField.length > 0) {
+        header.set(input.extraField, 30 + input.fileName.length);
+    }
+    return header;
+}
+export function buildCentralDirectoryHeader(input) {
+    const versionMadeBy = input.versionMadeBy ?? VERSION_MADE_BY;
+    const versionNeeded = input.versionNeeded ?? VERSION_NEEDED;
+    const externalAttributes = input.externalAttributes ?? 0;
+    const header = new Uint8Array(46 + input.fileName.length + input.extraField.length + input.comment.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, CENTRAL_DIR_HEADER_SIG, true);
+    view.setUint16(4, versionMadeBy, true);
+    view.setUint16(6, versionNeeded, true);
+    view.setUint16(8, input.flags, true);
+    view.setUint16(10, input.compressionMethod, true);
+    view.setUint16(12, input.dosTime, true);
+    view.setUint16(14, input.dosDate, true);
+    view.setUint32(16, input.crc32, true);
+    view.setUint32(20, input.compressedSize, true);
+    view.setUint32(24, input.uncompressedSize, true);
+    view.setUint16(28, input.fileName.length, true);
+    view.setUint16(30, input.extraField.length, true);
+    view.setUint16(32, input.comment.length, true);
+    view.setUint16(34, 0, true); // disk number start
+    view.setUint16(36, 0, true); // internal file attributes
+    view.setUint32(38, externalAttributes, true);
+    view.setUint32(42, input.localHeaderOffset, true);
+    header.set(input.fileName, 46);
+    if (input.extraField.length > 0) {
+        header.set(input.extraField, 46 + input.fileName.length);
+    }
+    if (input.comment.length > 0) {
+        header.set(input.comment, 46 + input.fileName.length + input.extraField.length);
+    }
+    return header;
+}
+export function buildEndOfCentralDirectory(input) {
+    const record = new Uint8Array(22 + input.comment.length);
+    const view = new DataView(record.buffer);
+    view.setUint32(0, END_OF_CENTRAL_DIR_SIG, true);
+    view.setUint16(4, 0, true);
+    view.setUint16(6, 0, true);
+    view.setUint16(8, input.entryCount, true);
+    view.setUint16(10, input.entryCount, true);
+    view.setUint32(12, input.centralDirSize, true);
+    view.setUint32(16, input.centralDirOffset, true);
+    view.setUint16(20, input.comment.length, true);
+    if (input.comment.length > 0) {
+        record.set(input.comment, 22);
+    }
+    return record;
+}
+export function buildDataDescriptor(crc32, compressedSize, uncompressedSize) {
+    const descriptor = new Uint8Array(16);
+    const view = new DataView(descriptor.buffer);
+    view.setUint32(0, DATA_DESCRIPTOR_SIG, true);
+    view.setUint32(4, crc32, true);
+    view.setUint32(8, compressedSize, true);
+    view.setUint32(12, uncompressedSize, true);
+    return descriptor;
+}

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

@@ -0,0 +1,215 @@
+/**
+ * CSV Parser and Formatter - RFC 4180 compliant
+ *
+ * A lightweight, cross-platform CSV implementation that works in both
+ * Node.js and Browser environments with zero dependencies.
+ *
+ * High-performance RFC 4180 compliant CSV parser and formatter.
+ *
+ * @see https://tools.ietf.org/html/rfc4180
+ */
+/** Header array type (can include undefined to skip columns) */
+export type HeaderArray = (string | undefined | null)[];
+/** Header transform function */
+export type HeaderTransformFunction = (headers: string[]) => HeaderArray;
+/** Row types */
+export type RowArray = string[];
+export type RowMap = Record<string, string>;
+export type Row = RowArray | RowMap;
+/** Row transform callback */
+export type RowTransformCallback<T> = (error?: Error | null, row?: T | null) => void;
+/** Row transform function - sync or async */
+export type RowTransformFunction<I = Row, O = Row> = ((row: I) => O | null) | ((row: I, callback: RowTransformCallback<O>) => void);
+/** Row validate callback */
+export type RowValidateCallback = (error?: Error | null, isValid?: boolean, reason?: string) => void;
+/** Row validate function - sync or async */
+export type RowValidateFunction<T = Row> = ((row: T) => boolean) | ((row: T, callback: RowValidateCallback) => void);
+/**
+ * CSV parsing options
+ */
+export interface CsvParseOptions {
+    /** Field delimiter (default: ",") */
+    delimiter?: string;
+    /** Quote character (default: '"'), set to false or null to disable quoting */
+    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) */
+    skipEmptyLines?: boolean;
+    /** Alias for skipEmptyLines */
+    ignoreEmpty?: boolean;
+    /** Trim whitespace from both sides of fields (default: false) */
+    trim?: boolean;
+    /** Left trim whitespace from fields (default: false) */
+    ltrim?: boolean;
+    /** Right trim whitespace from fields (default: false) */
+    rtrim?: boolean;
+    /**
+     * Header handling:
+     * - true: first row is headers, return objects
+     * - false: no headers, return arrays
+     * - string[]: use these as headers
+     * - function: transform first row headers
+     */
+    headers?: boolean | HeaderArray | HeaderTransformFunction;
+    /**
+     * If true and headers is string[], discard first row and use provided headers
+     */
+    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) */
+    skipLines?: number;
+    /** Number of data rows to skip (after header detection) */
+    skipRows?: number;
+    /**
+     * Strict column handling:
+     * - If true, rows with column count mismatch emit 'data-invalid' event
+     * - If false (default), throws error on mismatch (unless discardUnmappedColumns)
+     */
+    strictColumnHandling?: boolean;
+    /**
+     * If true, discard columns that exceed header count
+     * Only valid when headers are specified
+     */
+    discardUnmappedColumns?: boolean;
+    /**
+     * Enable object mode (default: true for Node.js streams)
+     * - true: push row objects/arrays
+     * - false: push JSON strings
+     */
+    objectMode?: boolean;
+    /**
+     * Character encoding for input (default: "utf8")
+     * Only used in Node.js streaming context
+     */
+    encoding?: BufferEncoding;
+    /**
+     * Synchronous transform function to apply to each row after parsing
+     * Return null/undefined to skip the row
+     * Works in both Node.js and Browser environments
+     *
+     * @example
+     * // With headers (row is Record<string, string>)
+     * transform: (row) => ({ ...row, name: row.name.toUpperCase() })
+     *
+     * // Without headers (row is string[])
+     * transform: (row) => [row[0].toUpperCase(), row[1]]
+     */
+    transform?: (row: Row) => Row | null | undefined;
+    /**
+     * Synchronous validate function to check each row
+     * Return false to mark row as invalid (will be in invalidRows)
+     * Can also return { isValid: boolean, reason?: string }
+     * Works in both Node.js and Browser environments
+     *
+     * @example
+     * // With headers
+     * validate: (row) => row.name !== ''
+     *
+     * // With custom reason
+     * validate: (row) => ({ isValid: row.age >= 18, reason: 'Must be adult' })
+     */
+    validate?: (row: Row) => boolean | {
+        isValid: boolean;
+        reason?: string;
+    };
+}
+/**
+ * CSV formatting options
+ */
+export interface CsvFormatOptions {
+    /** Field delimiter (default: ",") */
+    delimiter?: string;
+    /** Quote character (default: '"'), set to false or null to disable quoting */
+    quote?: string | false | null;
+    /** Escape character (default: same as quote) */
+    escape?: string | false | null;
+    /** Row delimiter (default: "\n") */
+    rowDelimiter?: string;
+    /**
+     * Decimal separator used when formatting numbers to CSV (default: ".").
+     * For European-style CSV, this is commonly "," (often together with delimiter ";").
+     */
+    decimalSeparator?: "." | ",";
+    /** Always quote all fields (default: false, only quote when necessary) */
+    alwaysQuote?: boolean;
+    /** Quote specific columns by name or index */
+    quoteColumns?: boolean | boolean[] | Record<string, boolean>;
+    /** Quote header fields */
+    quoteHeaders?: boolean | boolean[] | Record<string, boolean>;
+    /**
+     * Header handling:
+     * - true: auto-detect headers from first object
+     * - false/null: no headers
+     * - string[]: use these as headers
+     */
+    headers?: string[] | boolean | null;
+    /**
+     * Whether to write headers (default: true when headers is provided)
+     * Set to false to suppress header row output
+     */
+    writeHeaders?: boolean;
+    /** Include BOM for UTF-8 (default: false) */
+    writeBOM?: boolean;
+    /** Include final row delimiter (default: true) */
+    includeEndRowDelimiter?: boolean;
+    /** Write headers even when there's no data (default: false) */
+    alwaysWriteHeaders?: boolean;
+    /**
+     * Transform function to apply to each row before formatting
+     * Can be sync (returns row) or async (calls callback)
+     */
+    transform?: RowTransformFunction<Row, Row>;
+    /**
+     * Enable object mode (default: true for Node.js streams)
+     * - true: accept row objects/arrays directly
+     * - false: accept JSON strings
+     */
+    objectMode?: boolean;
+}
+/**
+ * Parsed CSV result with headers
+ */
+export interface CsvParseResult<T = string[]> {
+    /** Header row (if headers option was true) */
+    headers?: string[];
+    /** Data rows */
+    rows: T[];
+    /** Invalid rows (when strictColumnHandling is true) */
+    invalidRows?: {
+        row: string[];
+        reason: string;
+    }[];
+}
+/**
+ * Check if a transform function is synchronous (1 argument) vs async (2 arguments)
+ */
+export declare function isSyncTransform<I, O>(transform: RowTransformFunction<I, O>): transform is (row: I) => O | null;
+/**
+ * Check if a validate function is synchronous (1 argument) vs async (2 arguments)
+ */
+export declare function isSyncValidate<T>(validate: RowValidateFunction<T>): validate is (row: T) => boolean;
+/**
+ * Parse a CSV string into rows of fields
+ */
+export declare function parseCsv(input: string, options?: CsvParseOptions): string[][] | CsvParseResult<Record<string, string>>;
+/**
+ * Format data as a CSV string
+ */
+export declare function formatCsv(data: (string | number | boolean | null | undefined)[][] | Record<string, any>[], options?: CsvFormatOptions): string;
+/**
+ * Async CSV parser that yields rows one at a time
+ */
+export declare function parseCsvStream(input: string | AsyncIterable<string>, options?: CsvParseOptions): AsyncGenerator<string[] | Record<string, string>, void, unknown>;