@cj-tech-master/excelts 3.0.1-canary.20251230173853.c3c79fa → 3.1.0-canary.20260102041828.82ed571

package/dist/types/modules/archive/parse.browser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ZIP Stream Parser - Browser Version
+ *
+ * A streaming ZIP parser for browsers using native DecompressionStream.
+ * Falls back to pure JavaScript implementation for older browsers.
+ * Uses the browser Duplex stream implementation for compatibility.
+ */
+import { Duplex } from "@stream";
+import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "@archive/parse.base";
+export type { CrxHeader, EntryProps, EntryVars, ParseOptions, ZipEntry };
+export type ParseStream = Duplex & {
+    promise(): Promise<void>;
+} & PullStreamPublicApi & {
+    crxHeader?: CrxHeader;
+};
+export declare function createParseClass(createInflateRawFn: InflateFactory): {
+    new (opts?: ParseOptions): ParseStream;
+};
+declare const BaseParse: new (opts?: ParseOptions) => ParseStream;
+export declare class Parse extends BaseParse {
+}
+export declare function createParse(opts?: ParseOptions): ParseStream;

package/dist/types/modules/archive/parse.d.ts

@@ -0,0 +1,16 @@
+import type { Duplex } from "@stream";
+import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "@archive/parse.base";
+export type { CrxHeader } from "@archive/parse.base";
+export type { EntryProps, EntryVars, ParseOptions, ZipEntry };
+export type ParseStream = Duplex & {
+    promise(): Promise<void>;
+} & PullStreamPublicApi & {
+    crxHeader?: CrxHeader;
+};
+export declare function createParseClass(createInflateRawFn: InflateFactory): {
+    new (opts?: ParseOptions): ParseStream;
+};
+declare const BaseParse: new (opts?: ParseOptions) => ParseStream;
+export declare class Parse extends BaseParse {
+}
+export declare function createParse(opts?: ParseOptions): ParseStream;

package/dist/types/modules/archive/streaming-compress.base.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared types for true streaming compression.
+ *
+ * Kept in a dedicated base module so Node.js and browser implementations
+ * don't depend on each other.
+ */
+export interface StreamCompressOptions {
+    level?: number;
+}
+export type StreamCallback = (err?: Error | null) => void;
+/**
+ * Minimal cross-platform streaming codec surface.
+ *
+ * Both Node.js (zlib / stream.Transform) and browser implementations
+ * support this subset.
+ */
+export interface StreamingCodec {
+    on(event: "data", listener: (chunk: Uint8Array) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: "data", listener: (chunk: Uint8Array) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    off(event: "data", listener: (chunk: Uint8Array) => void): this;
+    off(event: "end", listener: () => void): this;
+    off(event: "error", listener: (err: Error) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    write(chunk: Uint8Array, callback?: StreamCallback): boolean;
+    end(callback?: StreamCallback): unknown;
+    destroy(err?: Error): unknown;
+}
+export type DeflateStream = StreamingCodec;
+export type InflateStream = StreamingCodec;
+export declare function asError(err: unknown): Error;

package/dist/types/modules/archive/streaming-compress.browser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Browser True Streaming Compression
+ *
+ * Uses native CompressionStream("deflate-raw") for real chunk-by-chunk streaming.
+ * Falls back to buffered compression if not supported.
+ *
+ * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
+ */
+export type { StreamCompressOptions } from "@archive/streaming-compress.base";
+import { type DeflateStream, type InflateStream, type StreamCompressOptions } from "@archive/streaming-compress.base";
+/**
+ * Check if deflate-raw streaming compression is supported by this library.
+ *
+ * In browsers, the library always supports deflate-raw via the JS fallback.
+ * Native deflate-raw Web Streams support (CompressionStream/DecompressionStream)
+ * is used when available, but is not required.
+ */
+export declare function hasDeflateRaw(): boolean;
+/**
+ * Create a streaming DEFLATE compressor
+ */
+export declare function createDeflateStream(options?: StreamCompressOptions): DeflateStream;
+/**
+ * Create a streaming INFLATE decompressor
+ */
+export declare function createInflateStream(): InflateStream;

package/dist/types/modules/archive/streaming-compress.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Node.js True Streaming Compression
+ *
+ * Uses zlib.createDeflateRaw() with explicit flush() calls for real chunk-by-chunk streaming.
+ * Each write() immediately produces compressed output without waiting for end().
+ */
+export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "@archive/streaming-compress.base";
+import type { DeflateStream, InflateStream, StreamCompressOptions } from "@archive/streaming-compress.base";
+/**
+ * Create a true streaming DEFLATE compressor
+ * Returns a Transform stream that emits compressed data immediately after each write
+ */
+export declare function createDeflateStream(options?: StreamCompressOptions): DeflateStream;
+/**
+ * Create a true streaming INFLATE decompressor
+ */
+export declare function createInflateStream(): InflateStream;
+/**
+ * Check if true streaming deflate-raw is available
+ * In Node.js, zlib is always available, so this always returns true
+ */
+export declare function hasDeflateRaw(): boolean;

package/dist/types/modules/archive/streaming-zip.d.ts

@@ -0,0 +1,120 @@
+/**
+ * True Streaming ZIP creator - shared implementation.
+ *
+ * This module is intentionally platform-agnostic.
+ * - In Node builds it uses `./crc32` + `./streaming-compress` (zlib-backed).
+ * - In browser builds the bundler aliases those imports to their browser variants.
+ */
+import type { ZipTimestampMode } from "@archive/utils/timestamps";
+import type { ZipEntryInfo as UnzipZipEntryInfo } from "@archive/zip-entry-info";
+/**
+ * Internal entry info for central directory
+ */
+interface ZipEntryInfo {
+    name: Uint8Array;
+    extraField: Uint8Array;
+    flags: number;
+    crc: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    dosTime: number;
+    dosDate: number;
+    offset: number;
+}
+type CentralDirectoryEntryInfo = ZipEntryInfo;
+/**
+ * True Streaming ZIP File - compresses chunk by chunk
+ */
+export declare class ZipDeflateFile {
+    private _deflate;
+    private _crc;
+    private _uncompressedSize;
+    private _compressedSize;
+    private _finalized;
+    private _headerEmitted;
+    private _ondata;
+    private _centralDirEntryInfo;
+    private _pendingEnd;
+    private _emittedDataDescriptor;
+    private _localHeader;
+    private _completeResolve;
+    private _completeReject;
+    private _completePromise;
+    private _completeError;
+    private _dataQueue;
+    private _finalQueued;
+    readonly name: string;
+    readonly level: number;
+    readonly nameBytes: Uint8Array;
+    readonly dosTime: number;
+    readonly dosDate: number;
+    readonly extraField: Uint8Array;
+    private readonly _flags;
+    private readonly _compressionMethod;
+    private readonly _modTime;
+    constructor(name: string, options?: {
+        level?: number;
+        modTime?: Date;
+        timestamps?: ZipTimestampMode;
+    });
+    private _buildLocalHeader;
+    private _enqueueData;
+    private _flushQueue;
+    get ondata(): ((data: Uint8Array, final: boolean) => void) | undefined;
+    set ondata(cb: (data: Uint8Array, final: boolean) => void);
+    private _resolveComplete;
+    private _rejectComplete;
+    private _ensureCompletePromise;
+    private _tapCallback;
+    private _emitHeaderIfNeeded;
+    private _writeData;
+    private _endDeflateAndWait;
+    private _finalizeAfterWrite;
+    /**
+     * Push data - immediately compresses and outputs
+     * Returns a Promise that resolves when the write is complete.
+     * If final=true, it resolves after the data descriptor is emitted.
+     */
+    push(data: Uint8Array, final?: boolean, callback?: (err?: Error | null) => void): Promise<void>;
+    /**
+     * Emit local file header with Data Descriptor flag
+     */
+    private _emitHeader;
+    /**
+     * Emit Data Descriptor with CRC and sizes
+     */
+    private _emitDataDescriptor;
+    /**
+     * Returns a promise that resolves when the file is completely written
+     * (including data descriptor)
+     */
+    complete(): Promise<void>;
+    /**
+     * Get entry metadata in the same shape as unzip parser outputs.
+     * This is best-effort: writer-only fields like encryption are always false.
+     */
+    getEntryInfo(): UnzipZipEntryInfo | null;
+    /** Writer-only metadata for building the Central Directory. */
+    getCentralDirectoryEntryInfo(): CentralDirectoryEntryInfo | null;
+    isComplete(): boolean;
+}
+/**
+ * Streaming ZIP Creator - processes files sequentially
+ */
+export declare class StreamingZip {
+    private callback;
+    private entries;
+    private currentOffset;
+    private ended;
+    private endPending;
+    private fileQueue;
+    private fileQueueIndex;
+    private activeFile;
+    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void);
+    add(file: ZipDeflateFile): void;
+    private _processNextFile;
+    private _finalize;
+    end(): void;
+}
+export { StreamingZip as Zip, ZipDeflateFile as ZipDeflate };

package/dist/types/modules/archive/utils/binary.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tiny binary reader for Uint8Array-backed DataView.
+ * Shared by ZIP parsers.
+ */
+export declare function writeUint32LE(value: number): Uint8Array;
+export declare function readUint32LE(data: Uint8Array, offset: number): number;
+export declare class BinaryReader {
+    private view;
+    private offset;
+    private data;
+    constructor(data: Uint8Array, offset?: number);
+    get position(): number;
+    set position(value: number);
+    get remaining(): number;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readBigUint64(): bigint;
+    readBytes(length: number): Uint8Array;
+    readString(length: number, utf8?: boolean): string;
+    skip(length: number): void;
+    slice(start: number, end: number): Uint8Array;
+    peekUint32(offset: number): number;
+}

package/dist/types/modules/archive/utils/bytes.d.ts

@@ -0,0 +1,7 @@
+export declare function sumUint8ArrayLengths(arrays: readonly Uint8Array[]): number;
+export declare function concatUint8Arrays(arrays: readonly Uint8Array[]): Uint8Array;
+/**
+ * Find the first index of `pattern` within `buffer`.
+ * Returns -1 when not found.
+ */
+export declare function indexOfUint8ArrayPattern(buffer: Uint8Array, pattern: Uint8Array, startIndex?: number): number;

package/dist/types/modules/archive/utils/parse-buffer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parses sequential unsigned little endian numbers from the head of the passed buffer according to
+ * the specified format passed. If the buffer is not large enough to satisfy the full format,
+ * null values will be assigned to the remaining keys.
+ * @param buffer The buffer to sequentially extract numbers from.
+ * @param format Expected format to follow when extracting values from the buffer. A list of list entries
+ * with the following structure:
+ * [
+ *   [
+ *     <key>,  // Name of the key to assign the extracted number to.
+ *     <size>  // The size in bytes of the number to extract. possible values are 1, 2, 4, 8.
+ *   ],
+ *   ...
+ * ]
+ * @returns An object with keys set to their associated extracted values.
+ */
+export declare function parse(buffer: Uint8Array, format: [string, number][]): Record<string, number | null>;
+export declare function parseTyped<T>(buffer: Uint8Array, format: [string, number][]): T;

package/dist/types/modules/archive/utils/text.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared text encoding/decoding utilities.
+ *
+ * Caches encoder/decoder instances for performance.
+ */
+export declare const utf8Encoder: TextEncoder;
+export declare const utf8Decoder: TextDecoder;
+/**
+ * Encode a string as UTF-8.
+ */
+export declare function encodeUtf8(value: string): Uint8Array;
+/**
+ * Decode bytes as UTF-8.
+ */
+export declare function decodeUtf8(bytes: Uint8Array): string;
+/**
+ * Decode bytes as Latin-1/byte-to-char.
+ * Used as a fallback when UTF-8 flag is not set.
+ */
+export declare function decodeLatin1(bytes: Uint8Array): string;

package/dist/types/modules/archive/utils/timestamps.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DOS date/time helpers for ZIP files.
+ */
+/**
+ * Convert Date to DOS time/date fields.
+ *
+ * Note: uses local time fields (getHours/getMinutes/getSeconds),
+ * which matches common ZIP writer behavior.
+ */
+export declare function dateToDos(date: Date): [number, number];
+/**
+ * Parse DOS date/time to JS Date.
+ */
+export declare function parseDosDateTimeUTC(date: number, time?: number): Date;
+/**
+ * How to write timestamps in ZIP headers.
+ *
+ * ZIP always has DOS date/time fields; `dos+utc` additionally writes the Info-ZIP
+ * extended timestamp extra field (0x5455) for a UTC mtime.
+ */
+export type ZipTimestampMode = "dos" | "dos+utc";
+export declare function resolveZipLastModifiedDateFromUnixSeconds(dosDate: number, dosTime: number, mtimeUnixSeconds?: number): Date;
+export declare function resolveZipLastModifiedDateFromExtraField(dosDate: number, dosTime: number, extraField: Uint8Array): Date;
+export declare function buildZipTimestampExtraField(modTime: Date, mode: ZipTimestampMode): Uint8Array;
+export declare function dateToZipDos(modTime: Date): {
+    dosTime: number;
+    dosDate: number;
+};

package/dist/types/modules/archive/utils/zip-extra-fields.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ZIP extra field parsing helpers.
+ *
+ * Kept standalone so both streaming parser (`parse.base.ts`) and buffer parser
+ * (`zip-parser.ts`) can share ZIP64 + Info-ZIP timestamp handling.
+ */
+export interface ZipVars {
+    uncompressedSize: number;
+    compressedSize: number;
+    offsetToLocalFileHeader?: number;
+}
+export interface ZipExtraFields {
+    uncompressedSize?: number;
+    compressedSize?: number;
+    offsetToLocalFileHeader?: number;
+    /** Info-ZIP extended timestamp (0x5455) mtime, Unix seconds (UTC). */
+    mtimeUnixSeconds?: number;
+}
+export declare function parseZipExtraFields(extraField: Uint8Array, vars: ZipVars): ZipExtraFields;

package/dist/types/modules/archive/utils/zip-extra.d.ts

@@ -0,0 +1,18 @@
+export declare function unixSecondsFromDate(date: Date): number;
+/**
+ * Build Info-ZIP "Extended Timestamp" extra field (0x5455).
+ * We write only mtime (UTC, Unix seconds) to minimize size.
+ *
+ * Layout:
+ * - Header ID: 2 bytes (0x5455)
+ * - Data size: 2 bytes
+ * - Flags: 1 byte (bit0 = mtime)
+ * - mtime: 4 bytes (Unix seconds)
+ */
+export declare function buildExtendedTimestampExtraFieldFromUnixSeconds(unixSeconds: number): Uint8Array;
+export declare function buildExtendedTimestampExtraFieldFromDate(date: Date): Uint8Array;
+/**
+ * Parse Info-ZIP "Extended Timestamp" extra field (0x5455) and return mtime.
+ * Returns Unix seconds (UTC) if present.
+ */
+export declare function parseExtendedTimestampMtimeUnixSeconds(extraField: Uint8Array): number | undefined;

package/dist/types/modules/archive/zip-builder.d.ts

@@ -0,0 +1,117 @@
+/**
+ * ZIP file format builder
+ *
+ * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
+ * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *
+ * ZIP file structure:
+ * ┌──────────────────────────┐
+ * │   Local File Header 1    │
+ * │   File Data 1            │
+ * ├──────────────────────────┤
+ * │   Local File Header 2    │
+ * │   File Data 2            │
+ * ├──────────────────────────┤
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │  Central Directory 1     │
+ * │  Central Directory 2     │
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │ End of Central Directory │
+ * └──────────────────────────┘
+ */
+import { type CompressOptions } from "@archive/compress";
+import { type ZipTimestampMode } from "@archive/utils/timestamps";
+/**
+ * ZIP file entry
+ */
+export interface ZipEntry {
+    /** File name (can include directory path, use forward slashes) */
+    name: string;
+    /** File data (will be compressed unless level=0) */
+    data: Uint8Array;
+    /** File modification time (optional, defaults to current time) */
+    modTime?: Date;
+    /** File comment (optional) */
+    comment?: string;
+}
+/**
+ * ZIP builder options
+ */
+export interface ZipOptions extends CompressOptions {
+    /** ZIP file comment (optional) */
+    comment?: string;
+    /**
+     * Timestamp writing strategy.
+     * - "dos": only write DOS date/time fields (smallest output)
+     * - "dos+utc": also write UTC mtime in 0x5455 extra field (default, best practice)
+     */
+    timestamps?: ZipTimestampMode;
+}
+/**
+ * Create a ZIP file from entries (async)
+ *
+ * @param entries - Files to include in ZIP
+ * @param options - ZIP options
+ * @returns ZIP file as Uint8Array
+ *
+ * @example
+ * ```ts
+ * const zip = await createZip([
+ *   { name: "hello.txt", data: new TextEncoder().encode("Hello!") },
+ *   { name: "folder/file.txt", data: new TextEncoder().encode("Nested!") }
+ * ], { level: 6 });
+ * ```
+ */
+export declare function createZip(entries: ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;
+/**
+ * Create a ZIP file from entries (sync)
+ *
+ * This is supported in both Node.js and browser builds.
+ */
+export declare function createZipSync(entries: ZipEntry[], options?: ZipOptions): Uint8Array;
+/**
+ * Streaming ZIP builder for large files
+ * Writes chunks to a callback as they are generated
+ */
+export declare class ZipBuilder {
+    private entries;
+    private currentOffset;
+    private level;
+    private zipComment;
+    private timestamps;
+    private compressOptions;
+    private settings;
+    private finalized;
+    /**
+     * Create a new ZIP builder
+     * @param options - ZIP options
+     */
+    constructor(options?: ZipOptions);
+    /**
+     * Add a file to the ZIP (async)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFile(entry: ZipEntry): Promise<Uint8Array[]>;
+    /**
+     * Add a file to the ZIP (sync)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFileSync(entry: ZipEntry): Uint8Array[];
+    /**
+     * Finalize the ZIP and return central directory + end record
+     * @returns Central directory and end of central directory chunks
+     */
+    finalize(): Uint8Array[];
+    /**
+     * Get current number of entries
+     */
+    get entryCount(): number;
+    /**
+     * Get current ZIP data size (without central directory)
+     */
+    get dataSize(): number;
+}

package/dist/types/modules/archive/zip-constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ZIP format constants (PKWARE APPNOTE)
+ * Shared by ZIP writer and parser implementations.
+ */
+export declare const LOCAL_FILE_HEADER_SIG = 67324752;
+export declare const CENTRAL_DIR_HEADER_SIG = 33639248;
+export declare const END_OF_CENTRAL_DIR_SIG = 101010256;
+export declare const DATA_DESCRIPTOR_SIG = 134695760;
+export declare const ZIP64_END_OF_CENTRAL_DIR_SIG = 101075792;
+export declare const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 117853008;
+export declare const VERSION_NEEDED = 20;
+export declare const VERSION_MADE_BY = 20;
+export declare const COMPRESSION_STORE = 0;
+export declare const COMPRESSION_DEFLATE = 8;
+export declare const FLAG_UTF8 = 2048;
+export declare const FLAG_DATA_DESCRIPTOR = 8;
+export declare const UINT16_MAX = 65535;
+export declare const UINT32_MAX = 4294967295;

package/dist/types/modules/archive/zip-entry-info.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared ZIP entry metadata used by unzip parsers and higher-level extract APIs.
+ *
+ * This is intentionally platform-agnostic and does not depend on Node.js streams.
+ */
+export interface ZipEntryInfo {
+    /** File path within the ZIP */
+    path: string;
+    /** Whether this is a directory */
+    isDirectory: boolean;
+    /** Compressed size */
+    compressedSize: number;
+    /** Uncompressed size */
+    uncompressedSize: number;
+    /** Compression method (0 = stored, 8 = deflate) */
+    compressionMethod: number;
+    /** CRC-32 checksum */
+    crc32: number;
+    /** Last modified date */
+    lastModified: Date;
+    /** Offset to local file header */
+    localHeaderOffset: number;
+    /** File comment */
+    comment: string;
+    /** External file attributes */
+    externalAttributes: number;
+    /** Is encrypted */
+    isEncrypted: boolean;
+}

package/dist/types/modules/archive/zip-entry-metadata.d.ts

@@ -0,0 +1,23 @@
+import { type ZipTimestampMode } from "@archive/utils/timestamps";
+export interface ZipEntryMetadata {
+    nameBytes: Uint8Array;
+    commentBytes: Uint8Array;
+    dosTime: number;
+    dosDate: number;
+    extraField: Uint8Array;
+    compressionMethod: number;
+    flags: number;
+}
+export interface ZipEntryMetadataInput {
+    name: string;
+    comment?: string;
+    modTime: Date;
+    timestamps: ZipTimestampMode;
+    /** If true, set FLAG_DATA_DESCRIPTOR and expect CRC/sizes written later. */
+    useDataDescriptor: boolean;
+    /** If true, use DEFLATE; else STORE. */
+    deflate: boolean;
+}
+export declare function resolveZipCompressionMethod(deflate: boolean): number;
+export declare function resolveZipFlags(useDataDescriptor: boolean): number;
+export declare function buildZipEntryMetadata(input: ZipEntryMetadataInput): ZipEntryMetadata;

package/dist/types/modules/archive/zip-parser.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pure Uint8Array-based ZIP parser
+ * Works in both Node.js and browser environments
+ * No dependency on Node.js stream module
+ */
+import type { ZipEntryInfo } from "@archive/zip-entry-info";
+export type { ZipEntryInfo };
+/**
+ * ZIP parsing options
+ */
+export interface ZipParseOptions {
+    /** Whether to decode file names as UTF-8 (default: true) */
+    decodeStrings?: boolean;
+}
+/**
+ * High-level ZIP parser class
+ */
+export declare class ZipParser {
+    private data;
+    private entries;
+    private entryMap;
+    constructor(data: Uint8Array | ArrayBuffer, options?: ZipParseOptions);
+    /**
+     * Get all entries in the ZIP file
+     */
+    getEntries(): ZipEntryInfo[];
+    /**
+     * Get entry by path
+     */
+    getEntry(path: string): ZipEntryInfo | undefined;
+    /**
+     * Check if entry exists
+     */
+    hasEntry(path: string): boolean;
+    /**
+     * List all file paths
+     */
+    listFiles(): string[];
+    /**
+     * Extract a single file (async)
+     */
+    extract(path: string): Promise<Uint8Array | null>;
+    /**
+     * Extract a single file (sync)
+     *
+     * This is supported in both Node.js and browser builds.
+     */
+    extractSync(path: string): Uint8Array | null;
+    /**
+     * Extract all files (async)
+     */
+    extractAll(): Promise<Map<string, Uint8Array>>;
+    /**
+     * Extract all files (sync)
+     * Returns object with file paths as keys and Uint8Array content as values
+     */
+    extractAllSync(): Record<string, Uint8Array>;
+    /**
+     * Iterate over entries with async callback
+     */
+    forEach(callback: (entry: ZipEntryInfo, getData: () => Promise<Uint8Array>) => Promise<boolean | void>): Promise<void>;
+}