@cj-tech-master/excelts 4.2.1-canary.20260111102127.f808a37 → 4.2.1

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

@@ -25,4 +25,3 @@ export { WorkbookWriter, WorkbookReader, WorksheetWriter, WorksheetReader };
 export type { CsvReadOptions, CsvWriteOptions, CsvStreamReadOptions, CsvStreamWriteOptions } from "./modules/csv/csv.browser.js";
 export { CsvParserStream, CsvFormatterStream } from "./modules/csv/csv.browser.js";
 export * from "./modules/excel/utils/sheet-utils.js";
-export { zip, unzip, ZipArchive, ZipReader, UnzipEntry, type ZipOptions, type ZipEntryOptions, type UnzipOptions, type ArchiveSource, type ArchiveSink, crc32, crc32Update, crc32Finalize, compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions, createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./modules/archive/index.browser.js";

package/dist/types/modules/archive/byte-queue.d.ts

@@ -0,0 +1,18 @@
+export declare class ByteQueue {
+    private static readonly EMPTY;
+    private _buf;
+    private _start;
+    private _end;
+    private _cachedView;
+    private _cachedBuf;
+    private _cachedStart;
+    private _cachedEnd;
+    constructor(initial?: Uint8Array);
+    get length(): number;
+    isEmpty(): boolean;
+    view(): Uint8Array;
+    reset(data?: Uint8Array): void;
+    append(chunk: Uint8Array): void;
+    read(length: number): Uint8Array;
+    discard(length: number): void;
+}

package/dist/types/modules/archive/{compression/compress.browser.d.ts → compress.browser.d.ts}

@@ -10,9 +10,15 @@
  * - Safari >= 14.1
  * - Edge >= 89
  */
-import { type CompressOptions, hasCompressionStream } from "./compress.base.js";
+import { type CompressOptions } from "./compress.base.js";
 export { type CompressOptions };
-export { hasCompressionStream };
+/**
+ * Check if CompressionStream is available in this environment.
+ *
+ * Note: Some environments may expose CompressionStream but not support
+ * the "deflate-raw" format that ZIP requires.
+ */
+export declare function hasCompressionStream(): boolean;
 /**
  * Compress data using browser's native CompressionStream or JS fallback
  *

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

@@ -1,5 +1,4 @@
 import type { ZipTimestampMode } from "./utils/timestamps.js";
-export declare const DEFAULT_DEFLATE_LEVEL = 6;
 export declare const DEFAULT_COMPRESS_LEVEL = 6;
 export declare const DEFAULT_ZIP_LEVEL = 6;
 export declare const DEFAULT_ZIP_TIMESTAMPS: ZipTimestampMode;

package/dist/types/modules/archive/index.base.d.ts

@@ -5,7 +5,7 @@
  * Platform-specific entrypoints (index.ts / index.browser.ts) should re-export
  * from this file and then layer their platform-specific bindings.
  */
-export type { ArchiveSource } from "./io/archive-source.js";
-export type { ArchiveSink } from "./io/archive-sink.js";
-export { zip, ZipArchive, type ZipOptions, type ZipEntryOptions } from "./zip/index.js";
-export { unzip, ZipReader, UnzipEntry, type UnzipOptions } from "./unzip/index.js";
+export { createZip, createZipSync, ZipBuilder, type ZipEntry, type ZipOptions } from "./zip-builder.js";
+export { StreamingZip, ZipDeflateFile, Zip, ZipDeflate } from "./streaming-zip.js";
+export { extractAll, extractFile, listFiles, forEachEntry, ZipParser, type ExtractedFile, type ZipParseOptions } from "./extract.js";
+export type { ZipEntryInfo } from "./zip-entry-info.js";

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

@@ -5,6 +5,7 @@
  * browser-specific implementations so we can enforce export-surface parity.
  */
 export * from "./index.base.js";
-export { crc32, crc32Update, crc32Finalize } from "./compression/crc32.browser.js";
-export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compression/compress.browser.js";
-export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./compression/streaming-compress.browser.js";
+export { crc32, crc32Update, crc32Finalize } from "./crc32.browser.js";
+export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compress.browser.js";
+export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./streaming-compress.browser.js";
+export { Parse, createParse, type ParseOptions, type ZipEntry as StreamZipEntry } from "./parse.browser.js";

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

@@ -5,6 +5,7 @@
  * It groups all ZIP creation and extraction utilities in one place.
  */
 export * from "./index.base.js";
-export { crc32, crc32Update, crc32Finalize } from "./compression/crc32.js";
-export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compression/compress.js";
-export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./compression/streaming-compress.js";
+export { crc32, crc32Update, crc32Finalize } from "./crc32.js";
+export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "./compress.js";
+export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "./streaming-compress.js";
+export { Parse, createParse, type ParseOptions, type ZipEntry as StreamZipEntry } from "./parse.js";

package/dist/types/modules/archive/{unzip/stream.base.d.ts → parse.base.d.ts}

@@ -1,7 +1,6 @@
-import { Duplex, PassThrough, Transform, type Readable } from "../../stream/index.js";
-import { ByteQueue } from "../internal/byte-queue.js";
-import { parseZipExtraFields, type ZipExtraFields, type ZipVars } from "../utils/zip-extra-fields.js";
-export declare const DATA_DESCRIPTOR_SIGNATURE_BYTES: Uint8Array<ArrayBufferLike>;
+import { Duplex, PassThrough, Transform, type Readable } from "../stream/index.js";
+import { ByteQueue } from "./byte-queue.js";
+import { parseZipExtraFields, type ZipExtraFields, type ZipVars } from "./utils/zip-extra-fields.js";
 export declare const CRX_HEADER_FORMAT: [string, number][];
 export declare const LOCAL_FILE_HEADER_FORMAT: [string, number][];
 export declare const DATA_DESCRIPTOR_FORMAT: [string, number][];
@@ -120,14 +119,9 @@ export interface ValidatedDataDescriptorScanResult {
  */
 export declare function scanValidatedDataDescriptor(view: Uint8Array, dataDescriptorSignature: Uint8Array, bytesEmitted: number, startIndex?: number, out?: ValidatedDataDescriptorScanResult): ValidatedDataDescriptorScanResult;
 export interface StreamUntilValidatedDataDescriptorSource {
+    getView(): Uint8Array;
     getLength(): number;
     read(length: number): Uint8Array;
-    /** Optional: zero-copy chunk views for streaming writes. */
-    peekChunks?(length: number): Uint8Array[];
-    /** Optional: consume bytes previously written from peekChunks(). */
-    discard?(length: number): void;
-    indexOfPattern(pattern: Uint8Array, startIndex: number): number;
-    peekUint32LE(offset: number): number | null;
     isFinished(): boolean;
     onDataAvailable(cb: () => void): () => void;
     maybeReleaseWriteCallback?: () => void;
@@ -148,34 +142,6 @@ export declare function streamUntilValidatedDataDescriptor(options: StreamUntilV
 export interface ParseOptions {
     verbose?: boolean;
     forceStream?: boolean;
-    /**
-     * Browser-only: use a Web Worker to run inflate off the main thread.
-     * Defaults to false.
-     */
-    useWorkerInflate?: boolean;
-    /**
-     * Browser-only: provide an explicit Worker script URL.
-     *
-     * Useful under strict CSP that blocks `blob:` workers. When set, the browser
-     * parser will try to construct `new Worker(workerInflateUrl)`.
-     */
-    workerInflateUrl?: string;
-    /**
-     * Input backpressure high-water mark (bytes).
-     *
-     * When provided, implementations may delay the writable callback until the
-     * internal input buffer drops below `inputLowWaterMarkBytes`.
-     *
-     * This is primarily used by the browser parser, because its writable side
-     * otherwise tends to accept unlimited data and can cause large memory spikes.
-     */
-    inputHighWaterMarkBytes?: number;
-    /**
-     * Input backpressure low-water mark (bytes).
-     * When the internal buffer drops to (or below) this value, a delayed writable
-     * callback may be released.
-     */
-    inputLowWaterMarkBytes?: number;
     /**
      * Threshold (in bytes) for small file optimization.
      * Files smaller than this will use sync decompression (no stream overhead).

package/dist/types/modules/archive/{unzip/stream.browser.d.ts → parse.browser.d.ts}

@@ -5,8 +5,8 @@
  * Falls back to pure JavaScript implementation for older browsers.
  * Uses the browser Duplex stream implementation for compatibility.
  */
-import { Duplex } from "../../stream/index.js";
-import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./stream.base.js";
+import { Duplex } from "../stream/index.js";
+import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./parse.base.js";
 export type { CrxHeader, EntryProps, EntryVars, ParseOptions, ZipEntry };
 export type ParseStream = Duplex & {
     promise(): Promise<void>;

package/dist/types/modules/archive/{unzip/stream.d.ts → parse.d.ts}

@@ -1,6 +1,6 @@
-import type { Duplex } from "../../stream/index.js";
-import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./stream.base.js";
-export type { CrxHeader } from "./stream.base.js";
+import type { Duplex } from "../stream/index.js";
+import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./parse.base.js";
+export type { CrxHeader } from "./parse.base.js";
 export type { EntryProps, EntryVars, ParseOptions, ZipEntry };
 export type ParseStream = Duplex & {
     promise(): Promise<void>;

package/dist/types/modules/archive/{compression/streaming-compress.browser.d.ts → streaming-compress.browser.d.ts}

@@ -6,7 +6,7 @@
  *
  * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
  */
-export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "./streaming-compress.base.js";
+export type { StreamCompressOptions } from "./streaming-compress.base.js";
 import { type DeflateStream, type InflateStream, type StreamCompressOptions } from "./streaming-compress.base.js";
 /**
  * Check if deflate-raw streaming compression is supported by this library.

package/dist/types/modules/archive/{zip/stream.d.ts → streaming-zip.d.ts}

@@ -2,18 +2,17 @@
  * True Streaming ZIP creator - shared implementation.
  *
  * This module is intentionally platform-agnostic.
- * - In Node builds it uses `./compression/crc32` + `./compression/streaming-compress` (zlib-backed).
+ * - 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 "../utils/timestamps.js";
-import type { ZipEntryInfo as UnzipZipEntryInfo } from "../zip-spec/zip-entry-info.js";
+import type { ZipTimestampMode } from "./utils/timestamps.js";
+import type { ZipEntryInfo as UnzipZipEntryInfo } from "./zip-entry-info.js";
 /**
  * Internal entry info for central directory
  */
 interface ZipEntryInfo {
     name: Uint8Array;
     extraField: Uint8Array;
-    comment: Uint8Array;
     flags: number;
     crc: number;
     compressedSize: number;
@@ -35,62 +34,43 @@ export declare class ZipDeflateFile {
     private _finalized;
     private _headerEmitted;
     private _ondata;
-    private _onerror;
     private _centralDirEntryInfo;
     private _pendingEnd;
     private _emittedDataDescriptor;
     private _localHeader;
-    private _deflateWanted;
-    private _pendingChunks;
-    private _sampleBuffer;
-    private _sampleLen;
-    private _smartStore;
     private _completeResolve;
     private _completeReject;
     private _completePromise;
     private _completeError;
     private _dataQueue;
     private _finalQueued;
-    private _pushChain;
     readonly name: string;
     readonly level: number;
     readonly nameBytes: Uint8Array;
-    readonly commentBytes: Uint8Array;
     readonly dosTime: number;
     readonly dosDate: number;
     readonly extraField: Uint8Array;
     private readonly _flags;
-    private _compressionMethod;
+    private readonly _compressionMethod;
     private readonly _modTime;
     constructor(name: string, options?: {
         level?: number;
         modTime?: Date;
         timestamps?: ZipTimestampMode;
-        comment?: string;
-        smartStore?: boolean;
     });
-    private _buildCompressionMethod;
-    private _initDeflateStream;
     private _buildLocalHeader;
-    private _accumulateSample;
-    private _shouldDecide;
-    private _decideCompressionIfNeeded;
-    private _emitHeaderIfNeeded;
-    private _flushPendingChunks;
     private _enqueueData;
     private _flushQueue;
     get ondata(): ((data: Uint8Array, final: boolean) => void) | undefined;
     set ondata(cb: (data: Uint8Array, final: boolean) => void);
-    get onerror(): ((err: Error) => void) | undefined;
-    set onerror(cb: (err: Error) => void);
     private _resolveComplete;
     private _rejectComplete;
     private _ensureCompletePromise;
     private _tapCallback;
+    private _emitHeaderIfNeeded;
     private _writeData;
     private _endDeflateAndWait;
     private _finalizeAfterWrite;
-    private _pushUnchained;
     /**
      * Push data - immediately compresses and outputs
      * Returns a Promise that resolves when the write is complete.
@@ -128,13 +108,10 @@ export declare class StreamingZip {
     private currentOffset;
     private ended;
     private endPending;
-    private zipComment;
     private fileQueue;
     private fileQueueIndex;
     private activeFile;
-    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void, options?: {
-        comment?: string;
-    });
+    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void);
     add(file: ZipDeflateFile): void;
     private _processNextFile;
     private _finalize;

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

@@ -1,7 +1,7 @@
 /**
  * ZIP extra field parsing helpers.
  *
- * Kept standalone so both streaming parser (`stream.base.ts`) and buffer parser
+ * 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 {

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 "./compress.js";
+import { type ZipTimestampMode } from "./utils/timestamps.js";
+/**
+ * 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/zip-entry-metadata.d.ts → zip-entry-metadata.d.ts}

@@ -1,4 +1,4 @@
-import { type ZipTimestampMode } from "../utils/timestamps.js";
+import { type ZipTimestampMode } from "./utils/timestamps.js";
 export interface ZipEntryMetadata {
     nameBytes: Uint8Array;
     commentBytes: Uint8Array;

package/dist/{browser/modules/archive/unzip → types/modules/archive}/zip-parser.d.ts

@@ -3,7 +3,7 @@
  * Works in both Node.js and browser environments
  * No dependency on Node.js stream module
  */
-import type { ZipEntryInfo } from "@archive/zip-spec/zip-entry-info";
+import type { ZipEntryInfo } from "./zip-entry-info.js";
 export type { ZipEntryInfo };
 /**
  * ZIP parsing options

package/dist/types/modules/archive/{zip-spec/zip-records.d.ts → zip-records.d.ts}

@@ -3,23 +3,6 @@
  *
  * Shared by streaming zip writer and buffer zip builder.
  */
-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;
-export declare const ZIP_LOCAL_FILE_HEADER_FIXED_SIZE = 30;
-export declare const ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE = 46;
-export declare const ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE = 22;
 export interface ZipLocalFileHeaderInput {
     fileName: Uint8Array;
     extraField: Uint8Array;
@@ -32,7 +15,6 @@ export interface ZipLocalFileHeaderInput {
     uncompressedSize: number;
     versionNeeded?: number;
 }
-export declare function writeLocalFileHeaderInto(out: Uint8Array, view: DataView, offset: number, input: ZipLocalFileHeaderInput): number;
 export declare function buildLocalFileHeader(input: ZipLocalFileHeaderInput): Uint8Array;
 export interface ZipCentralDirectoryHeaderInput {
     fileName: Uint8Array;
@@ -50,7 +32,6 @@ export interface ZipCentralDirectoryHeaderInput {
     versionNeeded?: number;
     externalAttributes?: number;
 }
-export declare function writeCentralDirectoryHeaderInto(out: Uint8Array, view: DataView, offset: number, input: ZipCentralDirectoryHeaderInput): number;
 export declare function buildCentralDirectoryHeader(input: ZipCentralDirectoryHeaderInput): Uint8Array;
 export interface ZipEndOfCentralDirectoryInput {
     entryCount: number;
@@ -58,6 +39,5 @@ export interface ZipEndOfCentralDirectoryInput {
     centralDirOffset: number;
     comment: Uint8Array;
 }
-export declare function writeEndOfCentralDirectoryInto(out: Uint8Array, view: DataView, offset: number, input: ZipEndOfCentralDirectoryInput): number;
 export declare function buildEndOfCentralDirectory(input: ZipEndOfCentralDirectoryInput): Uint8Array;
 export declare function buildDataDescriptor(crc32: number, compressedSize: number, uncompressedSize: number): Uint8Array<ArrayBuffer>;

package/dist/types/modules/excel/stream/workbook-writer.browser.d.ts

@@ -7,7 +7,7 @@
  * Node.js uses `workbook-writer.ts`, which extends the same base implementation
  * with filesystem-specific features (filename output + image loading).
  */
-import { Zip } from "../../archive/zip/stream.js";
+import { Zip } from "../../archive/streaming-zip.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { StylesXform } from "../xlsx/xform/style/styles-xform.js";
 import { SharedStrings } from "../utils/shared-strings.js";