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

package/dist/browser/modules/archive/zip/writable-file.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Writable file interface for streaming ZIP creation.
+ *
+ * This interface defines the contract between file writers (compressors, passthrough)
+ * and the StreamingZip pipeline.
+ *
+ * @module
+ */
+/**
+ * Central directory entry information required by the ZIP writer.
+ *
+ * This represents the metadata for a single entry in the Central Directory.
+ * Field names match ZIP specification naming conventions.
+ */
+export interface ZipCentralDirEntry {
+    /** File name as UTF-8 encoded bytes */
+    name: Uint8Array;
+    /** Extra field data (may include ZIP64, timestamps, etc.) */
+    extraField: Uint8Array;
+    /** File comment as UTF-8 encoded bytes */
+    comment: Uint8Array;
+    /** General purpose bit flags */
+    flags: number;
+    /** CRC-32 of uncompressed data */
+    crc: number;
+    /** Compressed size in bytes */
+    compressedSize: number;
+    /** Uncompressed size in bytes */
+    uncompressedSize: number;
+    /** Compression method (0=store, 8=deflate, 99=AES) */
+    compressionMethod: number;
+    /** MS-DOS time */
+    dosTime: number;
+    /** MS-DOS date */
+    dosDate: number;
+    /** Offset of local file header from start of archive */
+    offset: number;
+    /** Whether this entry uses ZIP64 extensions */
+    zip64: boolean;
+    /** External file attributes (platform-specific) */
+    externalAttributes: number;
+    /** Version made by (optional, defaults to standard) */
+    versionMadeBy?: number;
+}
+/**
+ * Minimal interface required by the StreamingZip pipeline.
+ *
+ * Implemented by:
+ * - `ZipDeflateFile` - Compresses and optionally encrypts data chunk by chunk
+ * - `ZipRawFile` - Passes through pre-compressed/pre-encrypted data
+ *
+ * The writer lifecycle:
+ * 1. Writer is created and added to StreamingZip via `add()`
+ * 2. StreamingZip sets `ondata` and `onerror` callbacks
+ * 3. StreamingZip calls `start()` if present (for passthrough writers)
+ * 4. Writer emits data via `ondata(data, false)` for each chunk
+ * 5. Writer emits final data via `ondata(data, true)` when done
+ * 6. `getCentralDirectoryEntryInfo()` returns metadata for CD
+ */
+export interface ZipWritableFile {
+    /**
+     * Callback invoked when output data is ready.
+     *
+     * @param data - Output bytes (local header, compressed data, data descriptor)
+     * @param final - True if this is the last chunk for this entry
+     */
+    ondata: ((data: Uint8Array, final: boolean) => void) | null;
+    /**
+     * Callback invoked when an error occurs.
+     *
+     * @param err - The error that occurred
+     */
+    onerror: ((err: Error) => void) | null;
+    /**
+     * Get the Central Directory entry information for this file.
+     *
+     * This is called after the file has completed writing to get
+     * the final metadata (CRC, sizes, etc.) for the Central Directory.
+     *
+     * @returns Entry info or null if not yet available
+     */
+    getCentralDirectoryEntryInfo(): ZipCentralDirEntry | null;
+    /**
+     * Abort writing this entry.
+     *
+     * @param reason - Optional abort reason
+     */
+    abort(reason?: unknown): void;
+    /**
+     * Optional hook to begin producing output.
+     *
+     * Some writers (e.g. passthrough raw entries) only start emitting data
+     * once this is called. This allows the StreamingZip to control when
+     * the writer begins output.
+     */
+    start?(): Promise<void>;
+}

package/dist/browser/modules/archive/zip/writable-file.js

@@ -0,0 +1,9 @@
+/**
+ * Writable file interface for streaming ZIP creation.
+ *
+ * This interface defines the contract between file writers (compressors, passthrough)
+ * and the StreamingZip pipeline.
+ *
+ * @module
+ */
+export {};

package/dist/browser/modules/archive/zip/writer-core.d.ts

@@ -0,0 +1,77 @@
+import type { Zip64Mode } from "../zip-spec/zip-records.js";
+import type { ZipCentralDirEntry } from "./writable-file.js";
+/**
+ * Input type for building Central Directory entries.
+ *
+ * This is a superset of ZipCentralDirEntry with fields renamed to match
+ * the build function naming conventions.
+ */
+export interface ZipCentralDirectoryEntryInput {
+    fileName: Uint8Array;
+    extraField: Uint8Array;
+    comment: Uint8Array;
+    flags: number;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    dosTime: number;
+    dosDate: number;
+    localHeaderOffset: number;
+    zip64?: boolean;
+    externalAttributes: number;
+    versionMadeBy?: number;
+}
+export interface ZipCentralDirectoryBuildResult {
+    centralDirectoryHeaders: Uint8Array[];
+    centralDirSize: number;
+    trailerRecords: Uint8Array[];
+    usedZip64: boolean;
+}
+export interface ZipCentralDirectoryWriteResult {
+    centralDirSize: number;
+    trailerSize: number;
+    totalWritten: number;
+    usedZip64: boolean;
+}
+export interface ZipCentralDirectorySizingResult {
+    centralDirSize: number;
+    trailerSize: number;
+    totalSize: number;
+    usedZip64: boolean;
+}
+type ZipCentralDirectoryBuildEntry = ZipCentralDirectoryEntryInput | ZipCentralDirEntry;
+type ZipCentralDirectoryProcessedEntry = {
+    name: Uint8Array;
+    extraField: Uint8Array;
+    comment: Uint8Array;
+    flags: number;
+    crc: number;
+    compressedData: Uint8Array;
+    uncompressedSize: number;
+    compressionMethod: number;
+    modTime: number;
+    modDate: number;
+    offset: number;
+    externalAttributes: number;
+    versionMadeBy?: number;
+};
+type AnyCentralDirectoryEntry = ZipCentralDirectoryBuildEntry | ZipCentralDirectoryProcessedEntry;
+export declare function measureCentralDirectoryAndEocd(entries: AnyCentralDirectoryEntry[], options: {
+    zipComment: Uint8Array;
+    zip64Mode: Zip64Mode;
+    centralDirOffset: number;
+}): ZipCentralDirectorySizingResult;
+export declare function buildCentralDirectoryAndEocd(entries: AnyCentralDirectoryEntry[], options: {
+    zipComment: Uint8Array;
+    zip64Mode: Zip64Mode;
+    centralDirOffset: number;
+}): ZipCentralDirectoryBuildResult;
+export declare function writeCentralDirectoryAndEocdInto(entries: AnyCentralDirectoryEntry[], options: {
+    zipComment: Uint8Array;
+    zip64Mode: Zip64Mode;
+    centralDirOffset: number;
+    out: Uint8Array;
+    offset: number;
+}): ZipCentralDirectoryWriteResult;
+export {};

package/dist/browser/modules/archive/zip/writer-core.js

@@ -0,0 +1,270 @@
+import { EMPTY_UINT8ARRAY } from "../shared/bytes.js";
+import { buildEndOfCentralDirectory, buildZip64EndOfCentralDirectory, buildZip64EndOfCentralDirectoryLocator, buildZip64ExtraField, concatExtraFields, writeCentralDirectoryHeaderInto, writeEndOfCentralDirectoryInto, writeZip64EndOfCentralDirectoryInto, writeZip64EndOfCentralDirectoryLocatorInto, ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE, ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE, ZIP64_END_OF_CENTRAL_DIR_FIXED_SIZE, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_FIXED_SIZE, UINT16_MAX, UINT32_MAX, VERSION_MADE_BY, VERSION_NEEDED, VERSION_ZIP64 } from "../zip-spec/zip-records.js";
+function zip64ExtraLength(forceZip64, uncompressedSize, compressedSize, localHeaderOffset, needsZip64Entry) {
+    if (!needsZip64Entry) {
+        return 0;
+    }
+    let dataLen = 0;
+    if (forceZip64 || uncompressedSize > UINT32_MAX) {
+        dataLen += 8;
+    }
+    if (forceZip64 || compressedSize > UINT32_MAX) {
+        dataLen += 8;
+    }
+    if (forceZip64 || localHeaderOffset > UINT32_MAX) {
+        dataLen += 8;
+    }
+    return dataLen > 0 ? 4 + dataLen : 0;
+}
+function getEntryShape(entries) {
+    const first = entries[0];
+    return first?.fileName !== undefined
+        ? "input"
+        : first?.compressedData !== undefined
+            ? "processed"
+            : "central";
+}
+export function measureCentralDirectoryAndEocd(entries, options) {
+    const forceZip64 = options.zip64Mode === true;
+    const forbidZip64 = options.zip64Mode === false;
+    const shape = getEntryShape(entries);
+    let centralDirSize = 0;
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const fileName = shape === "input" ? entry.fileName : entry.name;
+        const extraFieldBase = entry.extraField;
+        const comment = entry.comment;
+        const compressedSize = shape === "processed" ? entry.compressedData.length : entry.compressedSize;
+        const uncompressedSize = entry.uncompressedSize;
+        const localHeaderOffset = shape === "input" ? entry.localHeaderOffset : entry.offset;
+        const zip64 = shape === "processed" ? undefined : entry.zip64;
+        const needsZip64Entry = forceZip64 ||
+            zip64 === true ||
+            localHeaderOffset > UINT32_MAX ||
+            compressedSize > UINT32_MAX ||
+            uncompressedSize > UINT32_MAX;
+        centralDirSize +=
+            ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE +
+                fileName.length +
+                extraFieldBase.length +
+                zip64ExtraLength(forceZip64, uncompressedSize, compressedSize, localHeaderOffset, needsZip64Entry) +
+                (comment?.length ?? 0);
+    }
+    const needsZip64EOCDFromArchive = entries.length > UINT16_MAX || options.centralDirOffset > UINT32_MAX;
+    const usedZip64 = forceZip64 || needsZip64EOCDFromArchive || centralDirSize > UINT32_MAX;
+    if (forbidZip64 && usedZip64) {
+        throw new Error("ZIP64 is required but zip64=false");
+    }
+    const trailerSize = usedZip64
+        ? ZIP64_END_OF_CENTRAL_DIR_FIXED_SIZE +
+            ZIP64_END_OF_CENTRAL_DIR_LOCATOR_FIXED_SIZE +
+            ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE +
+            options.zipComment.length
+        : ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE + options.zipComment.length;
+    return {
+        centralDirSize,
+        trailerSize,
+        totalSize: centralDirSize + trailerSize,
+        usedZip64
+    };
+}
+export function buildCentralDirectoryAndEocd(entries, options) {
+    const forceZip64 = options.zip64Mode === true;
+    const forbidZip64 = options.zip64Mode === false;
+    const centralDirOffset = options.centralDirOffset;
+    const needsZip64EOCDFromArchive = entries.length > UINT16_MAX || centralDirOffset > UINT32_MAX;
+    const centralDirectoryHeaders = new Array(entries.length);
+    let centralDirSize = 0;
+    const emitHeader = (index, fileName, extraFieldBase, comment, flags, crc32, compressedSize, uncompressedSize, compressionMethod, dosTime, dosDate, localHeaderOffset, zip64, externalAttributes, versionMadeBy) => {
+        const needsZip64Entry = forceZip64 ||
+            zip64 === true ||
+            localHeaderOffset > UINT32_MAX ||
+            compressedSize > UINT32_MAX ||
+            uncompressedSize > UINT32_MAX;
+        const zip64Extra = needsZip64Entry
+            ? buildZip64ExtraField({
+                uncompressedSize: forceZip64 || uncompressedSize > UINT32_MAX ? uncompressedSize : undefined,
+                compressedSize: forceZip64 || compressedSize > UINT32_MAX ? compressedSize : undefined,
+                localHeaderOffset: forceZip64 || localHeaderOffset > UINT32_MAX ? localHeaderOffset : undefined
+            })
+            : EMPTY_UINT8ARRAY;
+        const extraField = needsZip64Entry && zip64Extra.length > 0
+            ? concatExtraFields(extraFieldBase, zip64Extra)
+            : extraFieldBase;
+        const header = new Uint8Array(ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE +
+            fileName.length +
+            extraField.length +
+            (comment?.length ?? 0));
+        const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+        writeCentralDirectoryHeaderInto(header, view, 0, {
+            fileName,
+            extraField,
+            comment: comment ?? EMPTY_UINT8ARRAY,
+            flags,
+            compressionMethod,
+            dosTime,
+            dosDate,
+            crc32,
+            compressedSize: needsZip64Entry ? UINT32_MAX : compressedSize,
+            uncompressedSize: needsZip64Entry ? UINT32_MAX : uncompressedSize,
+            localHeaderOffset: needsZip64Entry ? UINT32_MAX : localHeaderOffset,
+            versionMadeBy: versionMadeBy ?? VERSION_MADE_BY,
+            versionNeeded: needsZip64Entry ? VERSION_ZIP64 : VERSION_NEEDED,
+            externalAttributes
+        });
+        centralDirectoryHeaders[index] = header;
+        centralDirSize += header.length;
+    };
+    const shape = getEntryShape(entries);
+    if (shape === "input") {
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            emitHeader(i, entry.fileName, entry.extraField, entry.comment, entry.flags, entry.crc32, entry.compressedSize, entry.uncompressedSize, entry.compressionMethod, entry.dosTime, entry.dosDate, entry.localHeaderOffset, entry.zip64, entry.externalAttributes, entry.versionMadeBy);
+        }
+    }
+    else if (shape === "central") {
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            emitHeader(i, entry.name, entry.extraField, entry.comment, entry.flags, entry.crc, entry.compressedSize, entry.uncompressedSize, entry.compressionMethod, entry.dosTime, entry.dosDate, entry.offset, entry.zip64, entry.externalAttributes, entry.versionMadeBy);
+        }
+    }
+    else {
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            emitHeader(i, entry.name, entry.extraField, entry.comment, entry.flags, entry.crc, entry.compressedData.length, entry.uncompressedSize, entry.compressionMethod, entry.modTime, entry.modDate, entry.offset, undefined, entry.externalAttributes, entry.versionMadeBy);
+        }
+    }
+    const usedZip64 = forceZip64 || needsZip64EOCDFromArchive || centralDirSize > UINT32_MAX;
+    if (forbidZip64 && usedZip64) {
+        throw new Error("ZIP64 is required but zip64=false");
+    }
+    if (usedZip64) {
+        const zip64EocdOffset = centralDirOffset + centralDirSize;
+        const zip64Eocd = buildZip64EndOfCentralDirectory({
+            entryCountOnDisk: entries.length,
+            entryCountTotal: entries.length,
+            centralDirSize,
+            centralDirOffset
+        });
+        const zip64Locator = buildZip64EndOfCentralDirectoryLocator({
+            zip64EndOfCentralDirectoryOffset: zip64EocdOffset,
+            totalDisks: 1
+        });
+        const eocd = buildEndOfCentralDirectory({
+            entryCount: UINT16_MAX,
+            centralDirSize: UINT32_MAX,
+            centralDirOffset: UINT32_MAX,
+            comment: options.zipComment
+        });
+        return {
+            centralDirectoryHeaders,
+            centralDirSize,
+            trailerRecords: [zip64Eocd, zip64Locator, eocd],
+            usedZip64
+        };
+    }
+    const eocd = buildEndOfCentralDirectory({
+        entryCount: entries.length,
+        centralDirSize,
+        centralDirOffset,
+        comment: options.zipComment
+    });
+    return {
+        centralDirectoryHeaders,
+        centralDirSize,
+        trailerRecords: [eocd],
+        usedZip64
+    };
+}
+export function writeCentralDirectoryAndEocdInto(entries, options) {
+    const forceZip64 = options.zip64Mode === true;
+    const sizing = measureCentralDirectoryAndEocd(entries, {
+        zipComment: options.zipComment,
+        zip64Mode: options.zip64Mode,
+        centralDirOffset: options.centralDirOffset
+    });
+    const shape = getEntryShape(entries);
+    let offset = options.offset;
+    const view = new DataView(options.out.buffer, options.out.byteOffset, options.out.byteLength);
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const fileName = shape === "input" ? entry.fileName : entry.name;
+        const extraFieldBase = entry.extraField;
+        const comment = entry.comment;
+        const flags = entry.flags;
+        const crc32 = shape === "input" ? entry.crc32 : entry.crc;
+        const compressedSize = shape === "processed" ? entry.compressedData.length : entry.compressedSize;
+        const uncompressedSize = entry.uncompressedSize;
+        const compressionMethod = entry.compressionMethod;
+        const dosTime = shape === "processed" ? entry.modTime : entry.dosTime;
+        const dosDate = shape === "processed" ? entry.modDate : entry.dosDate;
+        const localHeaderOffset = shape === "input" ? entry.localHeaderOffset : entry.offset;
+        const zip64 = shape === "processed" ? undefined : entry.zip64;
+        const externalAttributes = entry.externalAttributes;
+        const versionMadeBy = entry.versionMadeBy;
+        const needsZip64Entry = forceZip64 ||
+            zip64 === true ||
+            localHeaderOffset > UINT32_MAX ||
+            compressedSize > UINT32_MAX ||
+            uncompressedSize > UINT32_MAX;
+        const zip64Extra = needsZip64Entry
+            ? buildZip64ExtraField({
+                uncompressedSize: forceZip64 || uncompressedSize > UINT32_MAX ? uncompressedSize : undefined,
+                compressedSize: forceZip64 || compressedSize > UINT32_MAX ? compressedSize : undefined,
+                localHeaderOffset: forceZip64 || localHeaderOffset > UINT32_MAX ? localHeaderOffset : undefined
+            })
+            : EMPTY_UINT8ARRAY;
+        const extraField = needsZip64Entry && zip64Extra.length > 0
+            ? concatExtraFields(extraFieldBase, zip64Extra)
+            : extraFieldBase;
+        offset += writeCentralDirectoryHeaderInto(options.out, view, offset, {
+            fileName,
+            extraField,
+            comment: comment ?? EMPTY_UINT8ARRAY,
+            flags,
+            compressionMethod,
+            dosTime,
+            dosDate,
+            crc32,
+            compressedSize: needsZip64Entry ? UINT32_MAX : compressedSize,
+            uncompressedSize: needsZip64Entry ? UINT32_MAX : uncompressedSize,
+            localHeaderOffset: needsZip64Entry ? UINT32_MAX : localHeaderOffset,
+            versionMadeBy: versionMadeBy ?? VERSION_MADE_BY,
+            versionNeeded: needsZip64Entry ? VERSION_ZIP64 : VERSION_NEEDED,
+            externalAttributes
+        });
+    }
+    if (sizing.usedZip64) {
+        const zip64EocdOffset = options.centralDirOffset + sizing.centralDirSize;
+        offset += writeZip64EndOfCentralDirectoryInto(options.out, view, offset, {
+            entryCountOnDisk: entries.length,
+            entryCountTotal: entries.length,
+            centralDirSize: sizing.centralDirSize,
+            centralDirOffset: options.centralDirOffset
+        });
+        offset += writeZip64EndOfCentralDirectoryLocatorInto(options.out, view, offset, {
+            zip64EndOfCentralDirectoryOffset: zip64EocdOffset,
+            totalDisks: 1
+        });
+        writeEndOfCentralDirectoryInto(options.out, view, offset, {
+            entryCount: UINT16_MAX,
+            centralDirSize: UINT32_MAX,
+            centralDirOffset: UINT32_MAX,
+            comment: options.zipComment
+        });
+    }
+    else {
+        writeEndOfCentralDirectoryInto(options.out, view, offset, {
+            entryCount: entries.length,
+            centralDirSize: sizing.centralDirSize,
+            centralDirOffset: options.centralDirOffset,
+            comment: options.zipComment
+        });
+    }
+    return {
+        centralDirSize: sizing.centralDirSize,
+        trailerSize: sizing.trailerSize,
+        totalWritten: sizing.totalSize,
+        usedZip64: sizing.usedZip64
+    };
+}

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

@@ -0,0 +1,121 @@
+import type { ZipTimestampMode } from "../zip-spec/timestamps.js";
+import { type ArchiveSink } from "../io/archive-sink.js";
+import { type ArchiveSource } from "../io/archive-source.js";
+import { type Zip64Mode } from "../zip-spec/zip-records.js";
+import type { ZipOperation, ZipProgress, ZipStreamOptions } from "./progress.js";
+import type { ZipPathOptions } from "../zip-spec/zip-path.js";
+import type { ArchiveFormat } from "../formats/types.js";
+import { type ZipStringEncoding } from "../shared/text.js";
+/** Archive options */
+export interface ZipOptions {
+    /**
+     * Archive format: "zip" (default) or "tar".
+     * Note: format dispatch is handled by `zip()`.
+     */
+    format?: ArchiveFormat;
+    level?: number;
+    timestamps?: ZipTimestampMode;
+    comment?: string;
+    /** Optional entry name normalization. `false` keeps names as-is. */
+    path?: false | ZipPathOptions;
+    /** Optional string encoding for entry names/comments and archive comment. */
+    encoding?: ZipStringEncoding;
+    /** Default abort signal used by streaming operations. */
+    signal?: AbortSignal;
+    /** Default progress callback used by streaming operations. */
+    onProgress?: (p: ZipProgress) => void;
+    /** Default throttle for progress callbacks. */
+    progressIntervalMs?: number;
+    /**
+     * ZIP64 mode:
+     * - "auto" (default): write ZIP64 only when required by limits.
+     * - true: force ZIP64 structures even for small archives.
+     * - false: forbid ZIP64; throws if ZIP64 is required.
+     */
+    zip64?: Zip64Mode;
+    /**
+     * Default modification time for entries that don't specify `modTime`.
+     *
+     * If you need stable output across runs, either pass this explicitly or use `reproducible: true`.
+     */
+    modTime?: Date;
+    /**
+     * If true, bias defaults toward reproducible output:
+     * - default `modTime` becomes 1980-01-01 00:00:00 (local time)
+     * - default `timestamps` becomes "dos" (no UTC extra field)
+     */
+    reproducible?: boolean;
+    /**
+     * If true (default), automatically STORE incompressible data.
+     * If false, always follow `level` (DEFLATE when level > 0).
+     */
+    smartStore?: boolean;
+    /**
+     * If true, entries are written in their original input order.
+     * If false (default), entries are sorted alphabetically by name.
+     *
+     * Note: streaming output preserves the input order.
+     */
+    noSort?: boolean;
+}
+export interface ZipEntryOptions {
+    level?: number;
+    modTime?: Date;
+    atime?: Date;
+    ctime?: Date;
+    birthTime?: Date;
+    comment?: string;
+    /** Optional Unix mode/permissions for this entry. */
+    mode?: number;
+    /** Optional MS-DOS attributes (low 8 bits). */
+    msDosAttributes?: number;
+    /** Advanced override for external attributes. */
+    externalAttributes?: number;
+    /** Advanced override for versionMadeBy. */
+    versionMadeBy?: number;
+    /** Per-entry ZIP64 override. Defaults to the archive-level zip64 mode. */
+    zip64?: Zip64Mode;
+    /** Optional string encoding for this entry name/comment. */
+    encoding?: ZipStringEncoding;
+}
+export type { ZipOperation, ZipProgress, ZipStreamOptions } from "./progress.js";
+export declare class ZipArchive {
+    private readonly _options;
+    private readonly _streamDefaults;
+    private readonly _entries;
+    private _sealed;
+    constructor(options?: ZipOptions);
+    private _getCreateZipOptions;
+    add(name: string, source: ArchiveSource, options?: ZipEntryOptions): this;
+    /**
+     * Add a directory entry.
+     *
+     * Unified API consistent with TarArchive.
+     */
+    addDirectory(name: string, options?: Omit<ZipEntryOptions, "level">): this;
+    /**
+     * Add a symbolic link entry.
+     *
+     * Unified API consistent with TarArchive.
+     */
+    addSymlink(name: string, target: string, options?: Omit<ZipEntryOptions, "level">): this;
+    stream(options?: ZipStreamOptions): AsyncIterable<Uint8Array>;
+    operation(options?: ZipStreamOptions): ZipOperation;
+    /**
+     * Browser-only fast path: stream sources through CompressionStream while
+     * computing CRC incrementally. Avoids Blob.arrayBuffer() materialization.
+     */
+    private _browserStreamingBytes;
+    bytes(options?: ZipStreamOptions): Promise<Uint8Array>;
+    bytesSync(): Uint8Array;
+    pipeTo(sink: ArchiveSink, options?: ZipStreamOptions): Promise<void>;
+}
+/** ZIP options with format: "tar" */
+export interface ZipOptionsTar extends ZipOptions {
+    format: "tar";
+}
+/** ZIP options with format: "zip" (or default) */
+export interface ZipOptionsZip extends ZipOptions {
+    format?: "zip";
+}
+export declare function createZipArchive(options?: ZipOptionsZip): ZipArchive;