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

package/dist/types/utils/stream-buf.browser.d.ts

@@ -0,0 +1,41 @@
+interface StreamBufOptions {
+    bufSize?: number;
+    batch?: boolean;
+}
+type EventCallback = (...args: any[]) => void;
+declare class StreamBuf {
+    private bufSize;
+    private buffers;
+    private batch;
+    private corked;
+    private paused;
+    private encoding;
+    private pipes;
+    private events;
+    constructor(options?: StreamBufOptions);
+    on(event: string, callback: EventCallback): this;
+    once(event: string, callback: EventCallback): this;
+    off(event: string, callback: EventCallback): this;
+    emit(event: string, ...args: any[]): boolean;
+    removeListener(event: string, callback: EventCallback): this;
+    toBuffer(): Uint8Array | null;
+    private _getWritableBuffer;
+    private _pipe;
+    private _writeToBuffers;
+    write(data: any, encoding?: BufferEncoding | Function, callback?: Function): Promise<boolean>;
+    cork(): void;
+    private _flush;
+    uncork(): void;
+    end(chunk?: any, encoding?: BufferEncoding, callback?: Function): void;
+    read(size?: number): Uint8Array;
+    setEncoding(encoding: string): void;
+    pause(): void;
+    resume(): void;
+    isPaused(): boolean;
+    pipe(destination: any): any;
+    unpipe(destination: any): void;
+    unshift(): void;
+    wrap(): void;
+    push(chunk: any): boolean;
+}
+export { StreamBuf };

package/dist/types/utils/stream-buf.d.ts

@@ -0,0 +1,2 @@
+declare const StreamBuf: any;
+export { StreamBuf };

package/dist/types/utils/string-buf.d.ts

@@ -0,0 +1,20 @@
+interface StringBufOptions {
+    size?: number;
+    encoding?: BufferEncoding;
+}
+declare class StringBuf {
+    private _buf;
+    private _encoding;
+    private _inPos;
+    private _buffer;
+    constructor(options?: StringBufOptions);
+    get length(): number;
+    get capacity(): number;
+    get buffer(): Buffer;
+    toBuffer(): Buffer;
+    reset(position?: number): void;
+    private _grow;
+    addText(text: string): void;
+    addStringBuf(inBuf: StringBuf): void;
+}
+export { StringBuf };

package/dist/types/utils/unzip/buffer-stream.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Unzipper buffer-stream module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+import type { Readable } from "stream";
+export declare function bufferStream(entry: Readable): Promise<Buffer>;

package/dist/types/utils/unzip/extract.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Simple ZIP extraction utilities
+ * Provides easy-to-use Promise-based API for extracting ZIP files
+ * Works in both Node.js and browser environments
+ */
+import { type ZipEntryInfo } from "./zip-parser";
+/**
+ * Extracted file entry
+ */
+export interface ExtractedFile {
+    /** File path within the ZIP */
+    path: string;
+    /** File content as Uint8Array */
+    data: Uint8Array;
+    /** Whether this is a directory */
+    isDirectory: boolean;
+    /** Uncompressed size */
+    size: number;
+}
+/**
+ * Extract all files from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @returns Map of file paths to their content
+ *
+ * @example
+ * ```ts
+ * import { extractAll } from "./utils/unzip/extract";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const files = await extractAll(zipData);
+ *
+ * for (const [path, file] of files) {
+ *   console.log(`${path}: ${file.data.length} bytes`);
+ * }
+ * ```
+ */
+export declare function extractAll(zipData: Uint8Array | ArrayBuffer): Promise<Map<string, ExtractedFile>>;
+/**
+ * Extract a single file from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @param filePath - Path of the file to extract
+ * @returns File content as Uint8Array, or null if not found
+ *
+ * @example
+ * ```ts
+ * import { extractFile } from "./utils/unzip/extract";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const content = await extractFile(zipData, "readme.txt");
+ * if (content) {
+ *   console.log(new TextDecoder().decode(content));
+ * }
+ * ```
+ */
+export declare function extractFile(zipData: Uint8Array | ArrayBuffer, filePath: string): Promise<Uint8Array | null>;
+/**
+ * List all file paths in a ZIP buffer (without extracting content)
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @returns Array of file paths
+ *
+ * @example
+ * ```ts
+ * import { listFiles } from "./utils/unzip/extract";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const paths = await listFiles(zipData);
+ * console.log(paths); // ["file1.txt", "folder/file2.txt", ...]
+ * ```
+ */
+export declare function listFiles(zipData: Uint8Array | ArrayBuffer): Promise<string[]>;
+/**
+ * Iterate over ZIP entries with a callback (memory efficient for large ZIPs)
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @param callback - Async callback for each entry, return false to stop iteration
+ *
+ * @example
+ * ```ts
+ * import { forEachEntry } from "./utils/unzip/extract";
+ *
+ * await forEachEntry(zipData, async (path, getData) => {
+ *   if (path.endsWith(".xml")) {
+ *     const content = await getData();
+ *     console.log(new TextDecoder().decode(content));
+ *   }
+ *   return true; // continue iteration
+ * });
+ * ```
+ */
+export declare function forEachEntry(zipData: Uint8Array | ArrayBuffer, callback: (path: string, getData: () => Promise<Uint8Array>, entry: ZipEntryInfo) => Promise<boolean | void>): Promise<void>;
+export { ZipParser, type ZipEntryInfo, type ZipParseOptions } from "./zip-parser";

package/dist/types/utils/unzip/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Unzip utilities for parsing ZIP archives
+ *
+ * Two APIs are provided:
+ *
+ * 1. **Stream-based API** (Node.js only):
+ *    - `Parse`, `createParse` - Parse ZIP files as a stream
+ *    - Best for large files where you don't want to load entire file into memory
+ *    - Requires Node.js `stream` module
+ *
+ * 2. **Buffer-based API** (Browser + Node.js):
+ *    - `extractAll`, `extractFile`, `listFiles`, `forEachEntry`, `ZipParser`
+ *    - Works in both Node.js and browser environments
+ *    - Uses native `DecompressionStream` in browser, `zlib` in Node.js
+ *    - Best for files already loaded into memory (ArrayBuffer, Uint8Array)
+ *
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ */
+export { Parse, createParse, type ParseOptions, type ZipEntry } from "./parse";
+export { PullStream } from "./pull-stream";
+export { NoopStream } from "./noop-stream";
+export { bufferStream } from "./buffer-stream";
+export { parse as parseBuffer } from "./parse-buffer";
+export { parseDateTime } from "./parse-datetime";
+export { parseExtraField, type ExtraField, type ZipVars } from "./parse-extra-field";
+export { extractAll, extractFile, listFiles, forEachEntry, ZipParser, type ExtractedFile, type ZipEntryInfo, type ZipParseOptions } from "./extract";

package/dist/types/utils/unzip/noop-stream.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unzipper noop-stream module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+import { Transform } from "stream";
+import type { TransformCallback } from "stream";
+export declare class NoopStream extends Transform {
+    constructor();
+    _transform(_chunk: any, _encoding: BufferEncoding, cb: TransformCallback): void;
+}

package/dist/types/utils/unzip/parse-buffer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Unzipper parse-buffer module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+/**
+ * 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: Buffer, format: [string, number][]): Record<string, number | null>;

package/dist/types/utils/unzip/parse-datetime.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Unzipper parse-datetime module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+/**
+ * Dates in zip file entries are stored as DosDateTime
+ * Spec is here: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-dosdatetimetofiletime
+ */
+export declare function parseDateTime(date: number, time?: number): Date;

package/dist/types/utils/unzip/parse-extra-field.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Unzipper parse-extra-field module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+export interface ZipVars {
+    uncompressedSize: number;
+    compressedSize: number;
+    offsetToLocalFileHeader?: number;
+}
+export interface ExtraField {
+    uncompressedSize?: number;
+    compressedSize?: number;
+    offsetToLocalFileHeader?: number;
+}
+export declare function parseExtraField(extraField: Buffer, vars: ZipVars): ExtraField;

package/dist/types/utils/unzip/parse.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Unzipper parse module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+import { PassThrough } from "stream";
+import { PullStream } from "./pull-stream";
+import { NoopStream } from "./noop-stream";
+import { type ExtraField } from "./parse-extra-field";
+export interface ParseOptions {
+    verbose?: boolean;
+    forceStream?: boolean;
+}
+export interface CrxHeader {
+    version: number | null;
+    pubKeyLength: number | null;
+    signatureLength: number | null;
+    publicKey?: Buffer;
+    signature?: Buffer;
+}
+export interface EntryVars {
+    versionsNeededToExtract: number | null;
+    flags: number | null;
+    compressionMethod: number | null;
+    lastModifiedTime: number | null;
+    lastModifiedDate: number | null;
+    crc32: number | null;
+    compressedSize: number;
+    uncompressedSize: number;
+    fileNameLength: number | null;
+    extraFieldLength: number | null;
+    lastModifiedDateTime?: Date;
+    crxHeader?: CrxHeader;
+}
+export interface EntryProps {
+    path: string;
+    pathBuffer: Buffer;
+    flags: {
+        isUnicode: boolean;
+    };
+}
+export interface ZipEntry extends PassThrough {
+    path: string;
+    props: EntryProps;
+    type: "Directory" | "File";
+    vars: EntryVars;
+    extra: ExtraField;
+    size?: number;
+    __autodraining?: boolean;
+    autodrain: () => NoopStream & {
+        promise: () => Promise<void>;
+    };
+    buffer: () => Promise<Buffer>;
+}
+export declare class Parse extends PullStream {
+    private _opts;
+    crxHeader?: CrxHeader;
+    reachedCD?: boolean;
+    constructor(opts?: ParseOptions);
+    private _readRecord;
+    private _readCrxHeader;
+    private _readFile;
+    private _processDataDescriptor;
+    private _readCentralDirectoryFileHeader;
+    private _readEndOfCentralDirectoryRecord;
+    promise(): Promise<void>;
+}
+export declare function createParse(opts?: ParseOptions): Parse;

package/dist/types/utils/unzip/pull-stream.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Unzipper pull-stream module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+import { Duplex, PassThrough } from "stream";
+export declare class PullStream extends Duplex {
+    buffer: Buffer;
+    cb?: () => void;
+    finished: boolean;
+    match?: number;
+    __emittedError?: Error;
+    constructor();
+    _write(chunk: Buffer, _encoding: BufferEncoding, cb: () => void): void;
+    _read(): void;
+    /**
+     * The `eof` parameter is interpreted as `file_length` if the type is number
+     * otherwise (i.e. buffer) it is interpreted as a pattern signaling end of stream
+     */
+    stream(eof: number | Buffer, includeEof?: boolean): PassThrough;
+    pull(eof: number | Buffer, includeEof?: boolean): Promise<Buffer>;
+}

package/dist/types/utils/unzip/zip-parser.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Pure Uint8Array-based ZIP parser
+ * Works in both Node.js and browser environments
+ * No dependency on Node.js stream module
+ */
+/**
+ * Parsed ZIP entry
+ */
+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;
+}
+/**
+ * ZIP parsing options
+ */
+export interface ZipParseOptions {
+    /** Whether to decode file names as UTF-8 (default: true) */
+    decodeStrings?: boolean;
+}
+/**
+ * Parse ZIP file entries from Central Directory
+ */
+export declare function parseZipEntries(data: Uint8Array, options?: ZipParseOptions): ZipEntryInfo[];
+/**
+ * Extract file data for a specific entry
+ */
+export declare function extractEntryData(data: Uint8Array, entry: ZipEntryInfo): Promise<Uint8Array>;
+/**
+ * Extract file data synchronously (Node.js only)
+ */
+export declare function extractEntryDataSync(data: Uint8Array, entry: ZipEntryInfo): Uint8Array;
+/**
+ * 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, Node.js only)
+     */
+    extractSync(path: string): Uint8Array | null;
+    /**
+     * Extract all files (async)
+     */
+    extractAll(): Promise<Map<string, Uint8Array>>;
+    /**
+     * Extract all files (sync, Node.js only)
+     * 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>;
+}

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

@@ -1,13 +1,7 @@
 /**
  * Base utility functions shared between Node.js and Browser
- * All functions use standard Web APIs that work in both environments
- * (Node.js 16+ supports atob/btoa/TextEncoder/TextDecoder globally)
+ * Platform-independent implementations only
  */
-/**
- * Convert base64 string to Uint8Array
- * Uses native Buffer in Node.js for better performance
- */
-export declare function base64ToUint8Array(base64: string): Uint8Array;
 export declare function delay(ms: number): Promise<void>;
 export declare function nop(): void;
 export declare const inherits: <T extends new (...args: any[]) => any, S extends new (...args: any[]) => any>(cls: T, superCtor: S, statics?: any, prototype?: any) => void;
@@ -21,11 +15,6 @@ interface PathInfo {
 export declare function parsePath(filepath: string): PathInfo;
 export declare function getRelsPath(filepath: string): string;
 export declare function xmlDecode(text: string): string;
-/**
- * Encode special characters for XML output
- * Handles XML entities (< > & " ') and removes invalid control characters
- */
-export declare function xmlEncode(text: string): string;
 export declare function validInt(value: string | number): number;
 export declare function isDateFmt(fmt: string | null | undefined): boolean;
 export declare function parseBoolean(value: any): boolean;
@@ -37,13 +26,4 @@ export declare function objectFromProps<T = any>(props: string[], value?: T | nu
  * Works in both Node.js and browser environments
  */
 export declare function bufferToString(chunk: ArrayBuffer | Uint8Array | string): string;
-/**
- * Convert Uint8Array to base64 string
- * Uses native Buffer in Node.js, optimized chunked conversion in browser
- */
-export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
-/**
- * Convert string to UTF-16LE Uint8Array (used for Excel password hashing)
- */
-export declare function stringToUtf16Le(str: string): Uint8Array;
 export {};

package/dist/types/utils/utils.browser.d.ts

@@ -2,5 +2,28 @@
  * Browser utility functions
  * Re-exports shared utilities and adds browser-specific implementations
  */
-export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "@utils/utils.base";
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base";
+export declare function xmlEncode(text: string): string;
 export declare function fileExists(_path: string): Promise<boolean>;
+import { nop, dateToExcel, excelToDate, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, toIsoDateString, parseBoolean, range, toSortedArray, objectFromProps } from "./utils.base";
+/** @deprecated Import functions directly instead of using the utils object */
+export declare const utils: {
+    nop: typeof nop;
+    inherits: <T extends new (...args: any[]) => any, S extends new (...args: any[]) => any>(cls: T, superCtor: S, statics?: any, prototype?: any) => void;
+    dateToExcel: typeof dateToExcel;
+    excelToDate: typeof excelToDate;
+    parsePath: typeof parsePath;
+    getRelsPath: typeof getRelsPath;
+    xmlEncode: typeof xmlEncode;
+    xmlDecode: typeof xmlDecode;
+    validInt: typeof validInt;
+    isDateFmt: typeof isDateFmt;
+    fs: {
+        exists: typeof fileExists;
+    };
+    toIsoDateString: typeof toIsoDateString;
+    parseBoolean: typeof parseBoolean;
+    range: typeof range;
+    toSortedArray: typeof toSortedArray;
+    objectFromProps: typeof objectFromProps;
+};

package/dist/types/utils/utils.d.ts

@@ -2,5 +2,28 @@
  * Node.js utility functions
  * Re-exports shared utilities and adds Node.js-specific implementations
  */
-export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "@utils/utils.base";
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base";
+export declare function xmlEncode(text: string): string;
 export declare function fileExists(path: string): Promise<boolean>;
+import { nop, dateToExcel, excelToDate, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, toIsoDateString, parseBoolean, range, toSortedArray, objectFromProps } from "./utils.base";
+/** @deprecated Import functions directly instead of using the utils object */
+export declare const utils: {
+    nop: typeof nop;
+    inherits: <T extends new (...args: any[]) => any, S extends new (...args: any[]) => any>(cls: T, superCtor: S, statics?: any, prototype?: any) => void;
+    dateToExcel: typeof dateToExcel;
+    excelToDate: typeof excelToDate;
+    parsePath: typeof parsePath;
+    getRelsPath: typeof getRelsPath;
+    xmlEncode: typeof xmlEncode;
+    xmlDecode: typeof xmlDecode;
+    validInt: typeof validInt;
+    isDateFmt: typeof isDateFmt;
+    fs: {
+        exists: typeof fileExists;
+    };
+    toIsoDateString: typeof toIsoDateString;
+    parseBoolean: typeof parseBoolean;
+    range: typeof range;
+    toSortedArray: typeof toSortedArray;
+    objectFromProps: typeof objectFromProps;
+};

package/dist/types/utils/zip/compress.base.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Base compression utilities using Web Streams API
+ * Shared between Node.js and Browser implementations
+ *
+ * Uses CompressionStream/DecompressionStream API with "deflate-raw" format
+ * (raw DEFLATE without zlib header/trailer, required for ZIP files)
+ *
+ * Browser fallback: For browsers without deflate-raw support (Firefox < 113, Safari < 16.4),
+ * see deflate-fallback.ts for pure JS implementation
+ */
+/**
+ * Compression options
+ */
+export interface CompressOptions {
+    /**
+     * Compression level (0-9)
+     * - 0: No compression (STORE)
+     * - 1: Fastest compression
+     * - 6: Default compression (good balance)
+     * - 9: Best compression (slowest)
+     *
+     * Note: CompressionStream does not support level configuration,
+     * it uses a fixed level (~6)
+     */
+    level?: number;
+}
+/**
+ * Check if CompressionStream is available
+ */
+export declare function hasCompressionStream(): boolean;
+/**
+ * Compress using CompressionStream API
+ * Uses "deflate-raw" format (required for ZIP files)
+ *
+ * @param data - Data to compress
+ * @returns Compressed data
+ */
+export declare function compressWithStream(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decompress using DecompressionStream API
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export declare function decompressWithStream(data: Uint8Array): Promise<Uint8Array>;

package/dist/types/utils/zip/compress.browser.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Browser compression utilities
+ *
+ * Primary: CompressionStream API (Chrome 103+, Firefox 113+, Safari 16.4+)
+ * Fallback: Pure JS DEFLATE implementation for older browsers
+ *
+ * Supported browsers with fallback:
+ * - Chrome >= 85
+ * - Firefox >= 79
+ * - Safari >= 14
+ * - Edge >= 85
+ */
+import { type CompressOptions } from "./compress.base";
+export { type CompressOptions };
+/**
+ * Check if CompressionStream with "deflate-raw" is available
+ * Note: Chrome 80-102 has CompressionStream but not deflate-raw support
+ */
+export declare function hasCompressionStream(): boolean;
+/**
+ * Check if native zlib is available (always false in browser)
+ */
+export declare function hasNativeZlib(): boolean;
+/**
+ * Compress data using browser's native CompressionStream or JS fallback
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ *
+ * @example
+ * ```ts
+ * const data = new TextEncoder().encode("Hello, World!");
+ * const compressed = await compress(data, { level: 6 });
+ * ```
+ */
+export declare function compress(data: Uint8Array, options?: {
+    level?: number;
+}): Promise<Uint8Array>;
+/**
+ * Compress data synchronously using pure JS implementation
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ */
+export declare function compressSync(data: Uint8Array, options?: {
+    level?: number;
+}): Uint8Array;
+/**
+ * Decompress data using browser's native DecompressionStream or JS fallback
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export declare function decompress(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decompress data synchronously using pure JS implementation
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export declare function decompressSync(data: Uint8Array): Uint8Array;