@cj-tech-master/excelts 6.0.0-beta.4 → 6.0.0-beta.5

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

@@ -0,0 +1,23 @@
+import { TarArchive } from "./tar/tar-archive.js";
+import { ZipArchive, type ZipOptionsTar, type ZipOptionsZip } from "./zip/zip-archive.js";
+/**
+ * Create a new archive
+ *
+ * @param options - Archive options including format
+ * @returns ZipArchive or TarArchive depending on format option
+ *
+ * @example
+ * ```ts
+ * // Create ZIP archive (default)
+ * const zipArchive = zip();
+ * zipArchive.add("file.txt", "content");
+ * const zipBytes = await zipArchive.bytes();
+ *
+ * // Create TAR archive
+ * const tarArchive = zip({ format: "tar" });
+ * tarArchive.add("file.txt", "content");
+ * const tarBytes = await tarArchive.bytes();
+ * ```
+ */
+export declare function zip(options: ZipOptionsTar): TarArchive;
+export declare function zip(options?: ZipOptionsZip): ZipArchive;

package/dist/browser/modules/archive/create-archive.js

@@ -0,0 +1,13 @@
+import { TarArchive } from "./tar/tar-archive.js";
+import { ZipArchive } from "./zip/zip-archive.js";
+export function zip(options = {}) {
+    if (options.format === "tar") {
+        return new TarArchive({
+            modTime: options.modTime,
+            signal: options.signal,
+            onProgress: options.onProgress,
+            progressIntervalMs: options.progressIntervalMs
+        });
+    }
+    return new ZipArchive({ ...options, format: "zip" });
+}

package/dist/browser/modules/archive/fs/archive-file.d.ts

@@ -30,7 +30,7 @@
  * @module
  */
 import { type ArchiveSink } from "../io/archive-sink.js";
-import type { ArchiveFormat } from "../formats/types.js";
+import type { ArchiveFormat } from "../shared/types.js";
 import type { AddFileOptions, AddDirectoryOptions, AddGlobOptions, AddTarFileOptions, AddTarDirectoryOptions, AddTarGlobOptions, ExtractToOptions, ArchiveFileOptions, ArchiveFileOptionsZip, ArchiveFileOptionsTar, OpenArchiveOptionsZip, OpenArchiveOptionsTar, WriteArchiveOptions, ArchiveEntryInfo, ZipEntryInfo, ArchiveStreamOptions, ArchiveStreamOperation } from "./types.js";
 /**
  * Unified archive file class supporting both ZIP and TAR formats.

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

@@ -11,7 +11,7 @@ import type { Zip64Mode } from "../zip-spec/zip-records.js";
 import type { ZipEncryptionMethod } from "../crypto/index.js";
 import type { ZipPathOptions } from "../zip-spec/zip-path.js";
 import type { ZipStringEncoding } from "../shared/text.js";
-import type { ArchiveFormat } from "../formats/types.js";
+import type { ArchiveFormat } from "../shared/types.js";
 export type { ArchiveFormat };
 /** Entry data passed to transform function */
 export interface TransformEntryData {

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

@@ -9,13 +9,15 @@ export type { ArchiveSource } from "./io/archive-source.js";
 export type { ArchiveSink } from "./io/archive-sink.js";
 export { toAsyncIterable, toReadableStream } from "./io/archive-source.js";
 export { HttpRangeReader, BufferReader, RangeNotSupportedError, HttpRangeError, type RandomAccessReader, type HttpRangeReaderOptions, type HttpRangeReaderStats } from "./io/random-access.js";
-export { RemoteZipReader, Crc32MismatchError, type RemoteZipReaderOptions, type RemoteZipOpenOptions, type RemoteZipStats, type ExtractOptions } from "./io/remote-zip-reader.js";
+export { RemoteZipReader, Crc32MismatchError, type RemoteZipReaderOptions, type RemoteZipOpenOptions, type RemoteZipStats, type ExtractOptions } from "./unzip/remote-zip-reader.js";
 export { AbortError, createAbortError, isAbortError, throwIfAborted, ArchiveError, ZipParseError, InvalidZipSignatureError, EocdNotFoundError, DecryptionError, PasswordRequiredError, FileTooLargeError, UnsupportedCompressionError, EntrySizeMismatchError, type EntrySizeMismatchReason } from "./shared/errors.js";
-export { zip, ZipArchive, ZipEditor, editZip, editZipUrl, ZipEditPlan, type ZipOptions, type ZipEntryOptions, type ZipEditOptions, type ZipEditUrlOptions, type ZipEditWarning, type ZipEditOp, type ArchiveFormat } from "./zip/index.js";
-export { unzip, ZipReader, UnzipEntry, type UnzipOptions } from "./unzip/index.js";
+export { zip } from "./create-archive.js";
+export { unzip } from "./read-archive.js";
+export type { ArchiveFormat } from "./shared/types.js";
+export { ZipArchive, ZipEditor, editZip, editZipUrl, ZipEditPlan, type ZipOptions, type ZipEntryOptions, type ZipEditOptions, type ZipEditUrlOptions, type ZipEditWarning, type ZipEditOp } from "./zip/index.js";
+export { ZipReader, UnzipEntry, type UnzipOptions } from "./unzip/index.js";
 export type { ZipOperation, ZipProgress, ZipStreamOptions } from "./zip/index.js";
 export type { UnzipOperation, UnzipProgress, UnzipStreamOptions } from "./unzip/index.js";
-export { createArchive, createReader } from "./formats/index.js";
 export { TAR_BLOCK_SIZE, TAR_TYPE, TarArchive, TarReader, TarReaderEntry, createTarArchive, createTarReader, tar, tarSync, parseTar, parseTarStream, untar, isTarFile, isTarDirectory, isTarSymlink, isTarHardLink, isTarDataEntry, type TarType, type TarEntryInfo, type TarEntry, type TarHeaderOptions, type TarParseOptions, type TarArchiveOptions, type TarArchiveEntryOptions, type TarArchiveProgress, type TarArchiveStreamOptions, type TarArchiveOperation, type TarReaderOptions, type TarReaderProgress, type TarReaderStreamOptions, type TarReaderOperation } from "./tar/index.browser.js";
 export { base64ToUint8Array, uint8ArrayToBase64 } from "../../utils/utils.base.js";
 export { concatUint8Arrays, stringToUint8Array, uint8ArrayToString } from "../../utils/binary.js";

package/dist/browser/modules/archive/index.base.js

@@ -8,7 +8,7 @@
 export { toAsyncIterable, toReadableStream } from "./io/archive-source.js";
 // Random Access / HTTP Range reading
 export { HttpRangeReader, BufferReader, RangeNotSupportedError, HttpRangeError } from "./io/random-access.js";
-export { RemoteZipReader, Crc32MismatchError } from "./io/remote-zip-reader.js";
+export { RemoteZipReader, Crc32MismatchError } from "./unzip/remote-zip-reader.js";
 // Abort and Error types - all from centralized errors module
 export { 
 // Abort helpers
@@ -16,10 +16,10 @@ AbortError, createAbortError, isAbortError, throwIfAborted,
 // Error classes
 ArchiveError, ZipParseError, InvalidZipSignatureError, EocdNotFoundError, DecryptionError, PasswordRequiredError, FileTooLargeError, UnsupportedCompressionError, EntrySizeMismatchError } from "./shared/errors.js";
 // High-level APIs
-export { zip, ZipArchive, ZipEditor, editZip, editZipUrl, ZipEditPlan } from "./zip/index.js";
-export { unzip, ZipReader, UnzipEntry } from "./unzip/index.js";
-// Format registry (ZIP/TAR dispatch)
-export { createArchive, createReader } from "./formats/index.js";
+export { zip } from "./create-archive.js";
+export { unzip } from "./read-archive.js";
+export { ZipArchive, ZipEditor, editZip, editZipUrl, ZipEditPlan } from "./zip/index.js";
+export { ZipReader, UnzipEntry } from "./unzip/index.js";
 // TAR archive support (unified API compatible with ZIP)
 // Note: Gzip helpers are exported separately in index.ts / index.browser.ts
 export { TAR_BLOCK_SIZE, TAR_TYPE, 

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

@@ -0,0 +1,27 @@
+import type { ArchiveSource } from "./io/archive-source.js";
+import { TarReader } from "./tar/tar-archive.js";
+import { ZipReader, type UnzipOptionsTar, type UnzipOptionsZip } from "./unzip/zip-reader.js";
+/**
+ * Open an archive for reading
+ *
+ * @param source - Archive data source
+ * @param options - Options including format
+ * @returns ZipReader or TarReader depending on format option
+ *
+ * @example
+ * ```ts
+ * // Read ZIP archive (default)
+ * const zipReader = unzip(zipBytes);
+ * for await (const entry of zipReader.entries()) {
+ *   console.log(entry.path);
+ * }
+ *
+ * // Read TAR archive
+ * const tarReader = unzip(tarBytes, { format: "tar" });
+ * for await (const entry of tarReader.entries()) {
+ *   console.log(entry.path);
+ * }
+ * ```
+ */
+export declare function unzip(source: ArchiveSource, options: UnzipOptionsTar): TarReader;
+export declare function unzip(source: ArchiveSource, options?: UnzipOptionsZip): ZipReader;

package/dist/browser/modules/archive/read-archive.js

@@ -0,0 +1,12 @@
+import { TarReader } from "./tar/tar-archive.js";
+import { ZipReader } from "./unzip/zip-reader.js";
+export function unzip(source, options = {}) {
+    if (options.format === "tar") {
+        return new TarReader(source, {
+            signal: options.signal,
+            onProgress: options.onProgress,
+            progressIntervalMs: options.progressIntervalMs
+        });
+    }
+    return new ZipReader(source, { ...options, format: "zip" });
+}

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

@@ -1,28 +1 @@
-import type { ArchiveSource } from "../io/archive-source.js";
-import type { TarReader } from "../tar/tar-archive.js";
-import type { UnzipOptionsTar, UnzipOptionsZip, ZipReader } from "./zip-reader.js";
 export { UnzipEntry, ZipReader, type UnzipOptions, type UnzipOptionsTar, type UnzipOptionsZip, type UnzipOperation, type UnzipProgress, type UnzipStreamOptions } from "./zip-reader.js";
-/**
- * Open an archive for reading
- *
- * @param source - Archive data source
- * @param options - Options including format
- * @returns ZipReader or TarReader depending on format option
- *
- * @example
- * ```ts
- * // Read ZIP archive (default)
- * const zipReader = unzip(zipBytes);
- * for await (const entry of zipReader.entries()) {
- *   console.log(entry.path);
- * }
- *
- * // Read TAR archive
- * const tarReader = unzip(tarBytes, { format: "tar" });
- * for await (const entry of tarReader.entries()) {
- *   console.log(entry.path);
- * }
- * ```
- */
-export declare function unzip(source: ArchiveSource, options: UnzipOptionsTar): TarReader;
-export declare function unzip(source: ArchiveSource, options?: UnzipOptionsZip): ZipReader;

package/dist/browser/modules/archive/unzip/index.js

@@ -1,5 +1 @@
-import { createReader } from "../formats/index.js";
 export { UnzipEntry, ZipReader } from "./zip-reader.js";
-export function unzip(source, options) {
-    return createReader(source, options);
-}

package/dist/browser/modules/archive/{io → unzip}/remote-zip-reader.d.ts

@@ -15,7 +15,7 @@
  */
 import type { ZipEntryInfo } from "../zip-spec/zip-entry-info.js";
 import { type ZipStringEncoding } from "../shared/text.js";
-import type { RandomAccessReader, HttpRangeReaderOptions } from "./random-access.js";
+import type { RandomAccessReader, HttpRangeReaderOptions } from "../io/random-access.js";
 /**
  * Options for RemoteZipReader
  */

package/dist/browser/modules/archive/{io → unzip}/remote-zip-reader.js

@@ -16,13 +16,13 @@
 import { BinaryReader } from "../zip-spec/binary.js";
 import { crc32 } from "../compression/crc32.browser.js";
 import { zipCryptoVerifyPassword, aesVerifyPassword, AES_PASSWORD_VERIFY_LENGTH, AES_SALT_LENGTH, ZIP_CRYPTO_HEADER_SIZE } from "../crypto/index.js";
-import { processEntryData, processEntryDataStream, LOCAL_HEADER_FIXED_SIZE } from "../unzip/zip-extract-core.js";
+import { processEntryData, processEntryDataStream, LOCAL_HEADER_FIXED_SIZE } from "./zip-extract-core.js";
 import { EMPTY_UINT8ARRAY } from "../shared/bytes.js";
-import { pipeIterableToSink } from "./archive-sink.js";
+import { pipeIterableToSink } from "../io/archive-sink.js";
 import { EOCD_MAX_SEARCH_SIZE, ZIP64_EOCD_LOCATOR_SIZE, findEOCDSignature, parseEOCD, parseZIP64EOCDLocator, parseZIP64EOCD, applyZIP64ToEOCD, parseCentralDirectory } from "../zip-spec/zip-parser-core.js";
 import { resolveZipStringCodec } from "../shared/text.js";
 import { LOCAL_FILE_HEADER_SIG } from "../zip-spec/zip-records.js";
-import { HttpRangeReader } from "./random-access.js";
+import { HttpRangeReader } from "../io/random-access.js";
 /**
  * Error thrown when CRC32 validation fails
  */

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

@@ -3,7 +3,7 @@ import { type ParseOptions, type ZipEntry as ParseZipEntry } from "./stream.js";
 import { type ArchiveSink } from "../io/archive-sink.js";
 import { type ArchiveSource } from "../io/archive-source.js";
 import type { UnzipOperation, UnzipProgress, UnzipStreamOptions } from "./progress.js";
-import type { ArchiveFormat } from "../formats/types.js";
+import type { ArchiveFormat } from "../shared/types.js";
 import type { ZipStringEncoding } from "../shared/text.js";
 import type { ZipEntryType } from "../zip-spec/zip-entry-info.js";
 type PipeToOptions = {
@@ -101,4 +101,3 @@ export interface UnzipOptionsTar extends UnzipOptions {
 export interface UnzipOptionsZip extends UnzipOptions {
     format?: "zip";
 }
-export declare function createZipReader(source: ArchiveSource, options?: UnzipOptionsZip): ZipReader;

package/dist/browser/modules/archive/unzip/zip-reader.js

@@ -515,6 +515,3 @@ export class ZipReader {
         // No persistent resources in buffer mode.
     }
 }
-export function createZipReader(source, options) {
-    return new ZipReader(source, options);
-}

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

@@ -1,27 +1,3 @@
-import type { TarArchive } from "../tar/tar-archive.js";
-import type { ZipArchive, ZipOptionsTar, ZipOptionsZip } from "./zip-archive.js";
 export { ZipEditor, editZip, editZipUrl, type ZipEditOptions, type ZipEditUrlOptions, type ZipEditWarning } from "./zip-editor.js";
 export { ZipEditPlan, type ZipEditOp, type SerializedZipEditOp, type SerializedZipEditPlan } from "./zip-edit-plan.js";
-export type { ArchiveFormat } from "../formats/index.js";
 export { ZipArchive, type ZipOptions, type ZipEntryOptions, type ZipOptionsTar, type ZipOptionsZip, type ZipOperation, type ZipProgress, type ZipStreamOptions } from "./zip-archive.js";
-/**
- * Create a new archive
- *
- * @param options - Archive options including format
- * @returns ZipArchive or TarArchive depending on format option
- *
- * @example
- * ```ts
- * // Create ZIP archive (default)
- * const zipArchive = zip();
- * zipArchive.add("file.txt", "content");
- * const zipBytes = await zipArchive.bytes();
- *
- * // Create TAR archive
- * const tarArchive = zip({ format: "tar" });
- * tarArchive.add("file.txt", "content");
- * const tarBytes = await tarArchive.bytes();
- * ```
- */
-export declare function zip(options: ZipOptionsTar): TarArchive;
-export declare function zip(options?: ZipOptionsZip): ZipArchive;

package/dist/browser/modules/archive/zip/index.js

@@ -1,7 +1,3 @@
-import { createArchive } from "../formats/index.js";
 export { ZipEditor, editZip, editZipUrl } from "./zip-editor.js";
 export { ZipEditPlan } from "./zip-edit-plan.js";
 export { ZipArchive } from "./zip-archive.js";
-export function zip(options) {
-    return createArchive(options);
-}

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

@@ -4,7 +4,7 @@ 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 { ArchiveFormat } from "../shared/types.js";
 import { type ZipStringEncoding } from "../shared/text.js";
 /** Archive options */
 export interface ZipOptions {
@@ -118,4 +118,3 @@ export interface ZipOptionsTar extends ZipOptions {
 export interface ZipOptionsZip extends ZipOptions {
     format?: "zip";
 }
-export declare function createZipArchive(options?: ZipOptionsZip): ZipArchive;

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

@@ -1,11 +1,10 @@
 import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS, REPRODUCIBLE_ZIP_MOD_TIME } from "../shared/defaults.js";
-import { ZipDeflateFile, StreamingZip } from "./stream.js";
+import { ZipDeflateFile } from "./stream.js";
 import { createZip, createZipSync } from "./zip-bytes.js";
 import { collect, pipeIterableToSink } from "../io/archive-sink.js";
 import { toAsyncIterable, toUint8Array, toUint8ArraySync, isSyncArchiveSource, isInMemoryArchiveSource } from "../io/archive-source.js";
-import { createAsyncQueue } from "../shared/async-queue.js";
-import { createLinkedAbortController, createAbortError, throwIfAborted, toError } from "../shared/errors.js";
-import { ProgressEmitter } from "../shared/progress.js";
+import { throwIfAborted } from "../shared/errors.js";
+import { createZipOperation } from "./zip-output-pipeline.js";
 import { stringToUint8Array as encodeUtf8 } from "../../../utils/binary.js";
 import { buildDataDescriptor, FLAG_DATA_DESCRIPTOR, UINT16_MAX, UINT32_MAX, writeLocalFileHeaderInto } from "../zip-spec/zip-records.js";
 import { isNode } from "../../../utils/env.js";
@@ -88,147 +87,53 @@ export class ZipArchive {
         const signalOpt = options.signal ?? this._streamDefaults.signal;
         const onProgress = options.onProgress ?? this._streamDefaults.onProgress;
         const progressIntervalMs = options.progressIntervalMs ?? this._streamDefaults.progressIntervalMs;
-        const { controller, cleanup: cleanupAbortLink } = createLinkedAbortController(signalOpt);
-        const signal = controller.signal;
-        const progress = new ProgressEmitter({
-            type: "zip",
-            phase: "running",
-            entriesTotal: this._entries.length,
-            entriesDone: 0,
-            bytesIn: 0,
-            bytesOut: 0,
-            zip64: this._options.zip64
-        }, onProgress, { intervalMs: progressIntervalMs });
-        const queue = createAsyncQueue({
-            onCancel: () => {
-                // Consumer stopped reading; abort upstream work to avoid buffering.
-                try {
-                    controller.abort("cancelled");
-                }
-                catch {
-                    // ignore
-                }
-            }
-        });
-        const zip = new StreamingZip((err, data, final) => {
-            if (err) {
-                progress.update({ phase: progress.snapshot.phase === "aborted" ? "aborted" : "error" });
-                queue.fail(err);
-                return;
-            }
-            if (data.length) {
-                progress.mutate(s => {
-                    s.bytesOut += data.length;
-                });
-                queue.push(data);
-            }
-            if (final) {
-                if (progress.snapshot.phase === "running") {
-                    progress.update({ phase: "done" });
-                }
-                queue.close();
-            }
-        }, {
+        return createZipOperation(this._entries.length, {
             comment: this._options.comment,
             zip64: this._options.zip64,
             encoding: this._options.encoding
-        });
-        const onAbort = () => {
-            const err = createAbortError(signal.reason);
-            progress.update({ phase: "aborted" });
-            try {
-                zip.abort(err);
-            }
-            catch {
-                // ignore
-            }
-            queue.fail(err);
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-        (async () => {
-            try {
-                for (let i = 0; i < this._entries.length; i++) {
-                    throwIfAborted(signal);
-                    const entry = this._entries[i];
-                    let entryBytesIn = 0;
-                    progress.update({ currentEntry: { name: entry.name, index: i, bytesIn: 0 } });
-                    const file = new ZipDeflateFile(entry.name, buildZipDeflateFileOptions(entry.options, {
-                        level: this._options.level,
-                        modTime: this._options.modTime,
-                        timestamps: this._options.timestamps,
-                        smartStore: this._options.smartStore,
-                        zip64: this._options.zip64,
-                        path: this._options.path,
-                        encoding: this._options.encoding
-                    }));
-                    zip.add(file);
-                    const onChunk = (chunk) => {
-                        entryBytesIn += chunk.length;
-                        progress.mutate(s => {
-                            s.bytesIn += chunk.length;
-                            s.currentEntry = { name: entry.name, index: i, bytesIn: entryBytesIn };
-                        });
-                    };
-                    if (isSyncArchiveSource(entry.source)) {
-                        const bytes = toUint8ArraySync(entry.source);
-                        throwIfAborted(signal);
-                        onChunk(bytes);
-                        await file.push(bytes, true);
-                    }
-                    else {
-                        for await (const chunk of toAsyncIterable(entry.source, { signal, onChunk })) {
-                            throwIfAborted(signal);
-                            await file.push(chunk, false);
-                        }
-                        throwIfAborted(signal);
-                        await file.push(new Uint8Array(0), true);
-                    }
-                    await file.complete();
-                    progress.set("entriesDone", progress.snapshot.entriesDone + 1);
-                }
+        }, { signal: signalOpt, onProgress, progressIntervalMs }, async ({ zip, signal, progress }) => {
+            for (let i = 0; i < this._entries.length; i++) {
                 throwIfAborted(signal);
-                zip.end();
-            }
-            catch (e) {
-                const err = toError(e);
-                if (err.name === "AbortError") {
-                    progress.update({ phase: "aborted" });
-                    try {
-                        zip.abort(err);
-                    }
-                    catch {
-                        // ignore
-                    }
+                const entry = this._entries[i];
+                let entryBytesIn = 0;
+                progress.update({ currentEntry: { name: entry.name, index: i, bytesIn: 0 } });
+                const file = new ZipDeflateFile(entry.name, buildZipDeflateFileOptions(entry.options, {
+                    level: this._options.level,
+                    modTime: this._options.modTime,
+                    timestamps: this._options.timestamps,
+                    smartStore: this._options.smartStore,
+                    zip64: this._options.zip64,
+                    path: this._options.path,
+                    encoding: this._options.encoding
+                }));
+                zip.add(file);
+                const onChunk = (chunk) => {
+                    entryBytesIn += chunk.length;
+                    progress.mutate(s => {
+                        s.bytesIn += chunk.length;
+                        s.currentEntry = { name: entry.name, index: i, bytesIn: entryBytesIn };
+                    });
+                };
+                if (isSyncArchiveSource(entry.source)) {
+                    const bytes = toUint8ArraySync(entry.source);
+                    throwIfAborted(signal);
+                    onChunk(bytes);
+                    await file.push(bytes, true);
                 }
                 else {
-                    progress.update({ phase: "error" });
-                }
-                queue.fail(err);
-            }
-            finally {
-                try {
-                    signal.removeEventListener("abort", onAbort);
-                }
-                catch {
-                    // ignore
+                    for await (const chunk of toAsyncIterable(entry.source, { signal, onChunk })) {
+                        throwIfAborted(signal);
+                        await file.push(chunk, false);
+                    }
+                    throwIfAborted(signal);
+                    await file.push(new Uint8Array(0), true);
                 }
-                cleanupAbortLink();
-                progress.emitNow();
+                await file.complete();
+                progress.set("entriesDone", progress.snapshot.entriesDone + 1);
             }
-        })();
-        return {
-            iterable: queue.iterable,
-            signal,
-            abort(reason) {
-                controller.abort(reason);
-            },
-            pointer() {
-                return progress.snapshot.bytesOut;
-            },
-            progress() {
-                return progress.snapshotCopy();
-            }
-        };
+            throwIfAborted(signal);
+            zip.end();
+        });
     }
     /**
      * Browser-only fast path: stream sources through CompressionStream while
@@ -443,6 +348,3 @@ export class ZipArchive {
         await pipeIterableToSink(this.stream(options), sink);
     }
 }
-export function createZipArchive(options) {
-    return new ZipArchive(options);
-}