@zip.js/zip.js 2.11.2 → 2.11.4

package/index.cjs

@@ -211,6 +211,8 @@ const STRICTNESS_TOLERANT = "tolerant";
 const ERR_INVALID_FUNCTION_OPTION = "Invalid option (must be a function)";
 const ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
 const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
+const ERR_ABORTED = "The operation was aborted";
+const ABORT_ERROR_NAME = "AbortError";
 
 function checkFunctionOption(value) {
 	if (value && typeof value != FUNCTION_TYPE) {
@@ -226,6 +228,12 @@ function checkSignalOption(signal) {
 	return signal || UNDEFINED_VALUE;
 }
 
+function throwIfAborted(signal) {
+	if (signal && signal.aborted) {
+		throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME) : signal.reason;
+	}
+}
+
 function checkPasswordOption(password, rawPassword) {
 	if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
 		throw new Error(ERR_INVALID_PASSWORD_TYPE);
@@ -3754,11 +3762,13 @@ class BlobReader extends Reader {
 		const reader = this;
 		const { sourceBlob, size } = reader;
 		const { offset = 0, size: readSize = size - offset } = options || {};
-		if (!offset && readSize >= size) {
-			return toCompatibleReadable(sourceBlob.stream());
-		}
-		if (blobSliceReliable) {
-			return toCompatibleReadable(sourceBlob.slice(offset, offset + readSize).stream());
+		if (typeof sourceBlob.stream == FUNCTION_TYPE) {
+			if (!offset && readSize >= size) {
+				return toCompatibleReadable(sourceBlob.stream());
+			}
+			if (blobSliceReliable) {
+				return toCompatibleReadable(sourceBlob.slice(offset, offset + readSize).stream());
+			}
 		}
 		return super.createReadable(options);
 	}
@@ -5194,27 +5204,28 @@ class ZipReaderStream {
 				const { done, value } = await gen.next();
 				if (done)
 					return controller.close();
-				const chunk = {
-					...value,
-					readable: (function () {
-						const { readable, writable } = new TransformStream();
-						if (value.getData) {
-							getData();
-							return readable;
-						}
+				const entryReadable = (function () {
+					const { readable, writable } = new TransformStream();
+					if (value.getData) {
+						getData();
+						return readable;
+					}
 
-						async function getData() {
+					async function getData() {
+						try {
+							await value.getData(writable);
+						} catch (error) {
 							try {
-								await value.getData(writable);
-							} catch (error) {
-								try {
-									await writable.abort(error);
-								} catch {
-									// ignored
-								}
+								await writable.abort(error);
+							} catch {
+								// ignored
 							}
 						}
-					})()
+					}
+				})();
+				const chunk = {
+					...value,
+					readable: entryReadable
 				};
 				delete chunk.getData;
 				controller.enqueue(chunk);
@@ -5360,6 +5371,7 @@ let ZipEntry$1 = class ZipEntry {
 		const size = compressedSize;
 		const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 		const signal = checkSignalOption(getOptionValue$1(zipEntry, options, OPTION_SIGNAL));
+		throwIfAborted(signal);
 		const checkPasswordOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 		let checkOverlappingEntry = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
 		const checkOverlappingEntryOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY_ONLY);
@@ -6266,6 +6278,7 @@ const ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
 const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 const ERR_UNSUPPORTED_ENCRYPTION_USDZ = "Encryption is not supported in USDZ files";
+const ERR_UNSUPPORTED_SPLIT_USDZ = "Split zip files are not supported in USDZ files";
 const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set";
 const ERR_INVALID_EXTRAFIELD = "Invalid extra field (must be a Map)";
 const ERR_INVALID_EXTRAFIELD_TYPE = "Invalid extra field type (must be integer 0..65535)";
@@ -6280,6 +6293,7 @@ const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
 const ERR_UNDEFINED_COMPRESSION_METHOD = "Undefined compression method";
 const ERR_UNDETERMINED_SIZE = "Undetermined size";
 const ERR_UNDEFINED_READER = "Undefined reader";
+const ERR_INVALID_READER = "Invalid reader (must be a Reader instance, a ReadableStream instance, or an object with a 'readable' property)";
 const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
 const ERR_INVALID_UID = "Invalid uid (must be integer 0..2^32-1)";
 const ERR_INVALID_GID = "Invalid gid (must be integer 0..2^32-1)";
@@ -6311,6 +6325,9 @@ class ZipWriter {
 		const addSplitZipSignature =
 			availableSize > 0 && availableSize !== INFINITY_VALUE &&
 			maxSize > 0 && maxSize !== INFINITY_VALUE;
+		if (addSplitZipSignature && options[OPTION_USDZ]) {
+			throw new Error(ERR_UNSUPPORTED_SPLIT_USDZ);
+		}
 		Object.assign(this, {
 			writer,
 			addSplitZipSignature,
@@ -6426,6 +6443,7 @@ class ZipWriter {
 				}
 				const { offset, diskNumberStart } = entryPositions.get(entry);
 				Object.assign(entry, {
+					zip64Enabled: true,
 					zip64UncompressedSize,
 					zip64CompressedSize,
 					offset,
@@ -6884,6 +6902,7 @@ function resolveMetadata(zipWriter, name, options) {
 	const createTempStream = getFunctionOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
 	const signal = checkSignalOption(getOptionValue(zipWriter, options, OPTION_SIGNAL));
+	throwIfAborted(signal);
 	const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
 	const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
 	const registeredCodec = passThrough || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
@@ -7001,6 +7020,9 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	if (reader) {
 		reader = new GenericReader(reader);
 		await initStream(reader);
+		if (!reader.readable && !reader.readUint8Array) {
+			throw new Error(ERR_INVALID_READER);
+		}
 		({ size: contentSize } = reader);
 	}
 	return Object.assign({ reader }, resolveEntrySizes(zipWriter, Boolean(reader), contentSize, metadata, options));
@@ -7011,6 +7033,7 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 	let { dataDescriptor, zip64, level, compressionMethod } = metadata;
 	let maximumCompressedSize = 0;
 	let uncompressedSize = 0;
+	let unknownSize = false;
 	if (passThrough && hasContent) {
 		uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 		if (uncompressedSize === UNDEFINED_VALUE) {
@@ -7036,8 +7059,8 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 			if (contentSize === UNDEFINED_VALUE) {
 				dataDescriptor = true;
 				if (zip64 || zip64 === UNDEFINED_VALUE) {
-					zip64 = true;
-					uncompressedSize = maximumCompressedSize = MAX_32_BITS + 1;
+					zip64 = unknownSize = true;
+					maximumCompressedSize = MAX_32_BITS + 1;
 				}
 			} else {
 				options.uncompressedSize = uncompressedSize = contentSize;
@@ -7052,7 +7075,7 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 	if (emptyEntry && !zipCrypto && getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR) === UNDEFINED_VALUE) {
 		dataDescriptor = false;
 	}
-	const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
+	const zip64UncompressedSize = zip64Enabled || unknownSize || uncompressedSize >= MAX_32_BITS;
 	const zip64CompressedSize = zip64Enabled || maximumCompressedSize >= MAX_32_BITS;
 	if (zip64UncompressedSize || zip64CompressedSize) {
 		if (zip64 === false) {
@@ -7068,6 +7091,8 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 			dataDescriptor,
 			emptyEntry,
 			zip64,
+			zip64Enabled,
+			unknownSize,
 			zip64UncompressedSize,
 			zip64CompressedSize,
 			uncompressedSize,
@@ -7141,7 +7166,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 	if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 		throw new Error(ERR_UNDETERMINED_SIZE);
 	}
-	const directoryDataLength = createDirectoryRecords(files);
+	const { directoryDataLength, zip64Entries } = createDirectoryRecords(files);
 	let zip64 = getOptionValue(zipWriter, writerOptions, PROPERTY_NAME_ZIP64);
 	if (offset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || files.size >= MAX_16_BITS) {
 		if (zip64 === false) {
@@ -7149,6 +7174,8 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		} else {
 			zip64 = true;
 		}
+	} else if (zip64 === UNDEFINED_VALUE && zip64Entries) {
+		zip64 = true;
 	}
 	return offset - initialOffset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 }
@@ -7341,6 +7368,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		rawPassword,
 		level,
 		zip64,
+		zip64Enabled,
 		zip64UncompressedSize,
 		zip64CompressedSize,
 		zipCrypto,
@@ -7381,6 +7409,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		lockFileEntry,
 		versionMadeBy,
 		zip64,
+		zip64Enabled,
 		directory: Boolean(directory),
 		executable: Boolean(executable),
 		filenameUTF8: true,
@@ -7524,13 +7553,14 @@ function getHeaderInfo(options) {
 		zip64UncompressedSize,
 		zip64CompressedSize,
 		uncompressedSize,
+		unknownSize,
 		crc32
 	} = options;
 	let { version, compressionMethod } = options;
 	const compressed = !directory && isCompressed(compressionMethod, level);
 	let rawLocalExtraFieldZip64;
 	const uncompressedFile = passThrough || !compressed;
-	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
+	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || (uncompressedFile && !unknownSize)));
 	const writeLocalExtraFieldZip64 = zip64ExtraFieldComplete || (zip64 && dataDescriptor && (zip64UncompressedSize || zip64CompressedSize));
 	if (zip64 && (zip64UncompressedSize || zip64CompressedSize)) {
 		const length = 4 + 16;
@@ -7664,6 +7694,10 @@ function getHeaderInfo(options) {
 		throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 	}
 	const dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
+	const clampedLastModDate = dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate;
+	const storedLastModDate = getLength(rawExtraFieldExtendedTimestamp) ?
+		new Date(getTimeUnix(lastModDate) * 1000) :
+		getLength(rawExtraFieldNTFS) ? lastModDate : clampedLastModDate;
 	const {
 		headerArray,
 		headerView,
@@ -7673,7 +7707,7 @@ function getHeaderInfo(options) {
 		bitFlag: getBitFlag(level, useUnicodeFileNames, dataDescriptor, encrypted, compressionMethod),
 		compressionMethod,
 		uncompressedSize,
-		lastModDate: dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate,
+		lastModDate: clampedLastModDate,
 		rawLastModDate: rawLastModDateOption,
 		rawFilename,
 		zip64CompressedSize,
@@ -7708,7 +7742,7 @@ function getHeaderInfo(options) {
 		localHeaderView,
 		headerArray,
 		headerView,
-		lastModDate,
+		lastModDate: storedLastModDate,
 		rawLastModDate,
 		encrypted,
 		compressed,
@@ -7880,14 +7914,15 @@ function updateLocalHeader({
 
 
 async function closeFile(zipWriter, comment, options) {
-	const directoryDataLength = createDirectoryRecords(zipWriter.fileEntries);
+	const { directoryDataLength, zip64Entries } = createDirectoryRecords(zipWriter.fileEntries);
 	const { directoryStart, directoryEnd, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
 	const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
-	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryEnd, directoryDataLength, signatureLength });
+	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryEnd, directoryDataLength, signatureLength, zip64Entries });
 }
 
 function createDirectoryRecords(files) {
 	let directoryDataLength = 0;
+	let zip64Entries = false;
 	for (const [, fileEntry] of files) {
 		const {
 			rawFilename,
@@ -7900,11 +7935,20 @@ function createDirectoryRecords(files) {
 			extendedTimestamp,
 			extraFieldExtendedTimestampFlag,
 			lastModDate,
-			zip64UncompressedSize,
-			zip64CompressedSize,
+			zip64Enabled,
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
+		let { zip64UncompressedSize, zip64CompressedSize } = fileEntry;
+		if (!zip64Enabled) {
+			if (zip64UncompressedSize && uncompressedSize < MAX_32_BITS) {
+				zip64UncompressedSize = fileEntry.zip64UncompressedSize = false;
+			}
+			if (zip64CompressedSize && compressedSize < MAX_32_BITS) {
+				zip64CompressedSize = fileEntry.zip64CompressedSize = false;
+			}
+		}
+		zip64Entries = zip64Entries || zip64UncompressedSize || zip64CompressedSize;
 		const zip64Offset = fileEntry.offset >= MAX_32_BITS;
 		const zip64DiskNumberStart = fileEntry.diskNumberStart >= MAX_16_BITS;
 		let rawExtraFieldZip64;
@@ -7958,7 +8002,7 @@ function createDirectoryRecords(files) {
 		}
 		directoryDataLength += CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
 	}
-	return directoryDataLength;
+	return { directoryDataLength, zip64Entries };
 }
 
 async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
@@ -8078,7 +8122,7 @@ async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
 
 async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	const { writer } = zipWriter;
-	const { directoryStart, directoryEnd, signatureLength } = cdInfo;
+	const { directoryStart, directoryEnd, signatureLength, zip64Entries } = cdInfo;
 	let { directoryDataLength } = cdInfo;
 	let fileEntriesLength = zipWriter.fileEntries.size;
 	let diskNumber = directoryStart.diskNumber;
@@ -8098,6 +8142,8 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		} else {
 			zip64 = true;
 		}
+	} else if (zip64 === UNDEFINED_VALUE && zip64Entries) {
+		zip64 = true;
 	}
 	const endOfdirectoryRecord = createRecordWriter(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 	if (exceedsAvailableSize(writer, getLength(endOfdirectoryRecord.array) + commentLength)) {
@@ -8601,7 +8647,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.11.2";
+const VERSION = "2.11.4";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9502,8 +9548,6 @@ const ERR_INVALID_PASS_THROUGH = "Invalid passThrough option (use readerOptions.
 const ERR_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
 const ERR_ZIP_CRYPTO_LAST_MOD_DATE = "The last modification date of an entry encrypted with ZipCrypto cannot be changed when passThrough is set";
 const ERR_ABORT_EXPORT = "zipjs-abort-export";
-const ERR_ABORTED = "The operation was aborted";
-const ABORT_ERROR_NAME = "AbortError";
 const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 const INTERPRETED_EXTRA_FIELD_TYPES = new Set([
 	EXTRAFIELD_TYPE_ZIP64,
@@ -9997,12 +10041,14 @@ class ZipDirectoryEntry extends ZipEntry {
 		if (options.bufferedWrite === UNDEFINED_VALUE) {
 			options.bufferedWrite = true;
 		}
-		const entries = zipEntry.getChildren({ recursive: true }).filter(child => !isImplicitDirectory(child)).map(child => {
+		const children = zipEntry.getChildren({ recursive: true });
+		const entries = children.filter(child => !isImplicitDirectory(child)).map(child => {
 			const { name, entryOptions } = getChildEntryOptions(child, zipEntry, options);
 			return { name, size: child.directory ? 0 : getDeterminedSize(child, isPassThrough(child, options)), options: entryOptions };
 		});
 		const writeOrderGuaranteed = !options.bufferedWrite ||
-			(entries.every(entry => entry.options.keepOrder !== false) && zipEntry.children.every(child => !child.children.length));
+			(entries.every(entry => entry.options.keepOrder !== false) &&
+				children.every(child => isImplicitDirectory(child) || !child.children.length));
 		return getEntriesSize(options, entries, writeOrderGuaranteed, options.globalComment);
 	}
 
@@ -11031,6 +11077,7 @@ exports.ERR_INVALID_MSDOS_DATA = ERR_INVALID_MSDOS_DATA;
 exports.ERR_INVALID_PASSWORD = ERR_INVALID_PASSWORD;
 exports.ERR_INVALID_PASSWORD_TYPE = ERR_INVALID_PASSWORD_TYPE;
 exports.ERR_INVALID_PASS_THROUGH = ERR_INVALID_PASS_THROUGH;
+exports.ERR_INVALID_READER = ERR_INVALID_READER;
 exports.ERR_INVALID_READER_OPTIONS = ERR_INVALID_READER_OPTIONS;
 exports.ERR_INVALID_SIGNAL = ERR_INVALID_SIGNAL;
 exports.ERR_INVALID_SIGNATURE_DATA = ERR_INVALID_SIGNATURE_DATA;
@@ -11059,6 +11106,7 @@ exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
 exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+exports.ERR_UNSUPPORTED_SPLIT_USDZ = ERR_UNSUPPORTED_SPLIT_USDZ;
 exports.ERR_UNSUPPORTED_UINT64 = ERR_UNSUPPORTED_UINT64;
 exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;
 exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;

package/index.d.cts

@@ -161,7 +161,7 @@
 /**
  * Represents the `FileSystemEntry` class.
  *
- * @see {@link https://wicg.github.io/entries-api/#api-entry|specification}
+ * @see {@link https://wicg.github.io/entries-api/#api-entry}
  */
 // deno-lint-ignore no-empty-interface
 interface FileSystemEntryLike {}
@@ -177,7 +177,7 @@ interface FileSystemHandleLike {}
 /**
  * Represents a generic `TransformStream` class.
  *
- * @see {@link https://streams.spec.whatwg.org/#generictransformstream|specification}
+ * @see {@link https://streams.spec.whatwg.org/#generictransformstream}
  */
 declare class TransformStreamLike {
   /**
@@ -1344,6 +1344,10 @@ export class ZipReaderStream<T> {
 
   /**
    * The readable stream.
+   *
+   * @remarks The properties deposited on an entry while its data is read, i.e.
+   * {@link EntryMetaData#warnings} and {@link EntryMetaData#localDirectory}, are shared with the
+   * chunk, so they are readable on it once its `readable` property has been consumed.
    */
   readable: ReadableStream<
     Omit<Entry, "getData"> & { readable?: ReadableStream<Uint8Array> }
@@ -1880,6 +1884,10 @@ export interface ZipReaderOptions {
   rawPassword?: Uint8Array;
   /**
    * The `AbortSignal` instance used to cancel the decompression.
+   *
+   * A signal already aborted when the operation starts rejects it with {@link ERR_ABORTED} as the
+   * reason of the `AbortError`, or with `signal.reason` when it is set, without relying on the
+   * `signal` option of `pipeTo` that the oldest supported engines ignore.
    */
   signal?: AbortSignal;
   /**
@@ -3027,6 +3035,8 @@ export interface ZipWriterCloseOptions extends EntryOnprogressOptions {
   /**
    * `true` to use Zip64 to write the entries directory.
    *
+   * Zip64 is also used when the directory does not fit in the standard record, or when an entry is stored with Zip64.
+   *
    * @defaultValue false
    */
   zip64?: boolean;
@@ -3059,6 +3069,8 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * `true` to use Zip64 to store the entry.
    *
    * `zip64` is automatically set to `true` when necessary (e.g. compressed data larger than 4GB or with unknown size).
+   * An entry of unknown size is stored with Zip64 in its local header, because the size of the data descriptor must be
+   * chosen before writing the data. Its central directory record drops Zip64 when the actual sizes fit in 32 bits.
    *
    * @defaultValue false
    */
@@ -3080,6 +3092,12 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * between platforms. Set `useCompressionStream` to `false` to get deterministic output across
    * platforms.
    *
+   * When no deflate implementation is available at all, i.e. the environment provides no usable
+   * `CompressionStream` and the embedded implementation cannot be loaded, the entry is stored
+   * instead of being compressed rather than failing. The {@link EntryMetaData#compressionMethod} of
+   * the entry returned by {@link ZipWriter#add} is `0` in that case, which is how the fallback is
+   * detected.
+   *
    * @defaultValue 6
    */
   level?: number;
@@ -3145,6 +3163,10 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
   encryptionStrength?: 1 | 2 | 3;
   /**
    * The `AbortSignal` instance used to cancel the compression.
+   *
+   * A signal already aborted when the operation starts rejects it with {@link ERR_ABORTED} as the
+   * reason of the `AbortError`, or with `signal.reason` when it is set, without relying on the
+   * `signal` option of `pipeTo` that the oldest supported engines ignore.
    */
   signal?: AbortSignal;
   /**
@@ -3389,6 +3411,8 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * boundaries and stored uncompressed unless the {@link ZipWriterConstructorOptions#level} or
    * {@link ZipWriterAddDataOptions#compressionMethod} options are set explicitly. Setting the
    * {@link ZipWriterConstructorOptions#password} option throws an {@link ERR_UNSUPPORTED_ENCRYPTION_USDZ} error.
+   * Writing into a split zip file throws an {@link ERR_UNSUPPORTED_SPLIT_USDZ} error, since the 64-byte alignment
+   * of an entry is invalidated when the disk it is written into rolls over.
    *
    * These constraints apply to the entries written with {@link ZipWriter#add} only. The entries copied with
    * {@link ZipWriter#appendZip} keep the layout of the source zip file and are not checked, so appending a
@@ -4634,6 +4658,10 @@ export const ERR_INVALID_ENCRYPTION_STRENGTH: string;
  * Unsupported encryption in USDZ files error
  */
 export const ERR_UNSUPPORTED_ENCRYPTION_USDZ: string;
+/**
+ * Unsupported split zip file in USDZ files error
+ */
+export const ERR_UNSUPPORTED_SPLIT_USDZ: string;
 /**
  * Unsupported encryption in pass-through entries error
  */
@@ -4728,6 +4756,15 @@ export const ERR_UNDETERMINED_SIZE: string;
  * is not there. Directory entries are exempt, they have no content to write as-is.
  */
 export const ERR_UNDEFINED_READER: string;
+/**
+ * Invalid reader error
+ *
+ * @remarks Thrown when the second argument of {@link ZipWriter#add} is neither a {@link Reader} instance, a
+ * `ReadableStream` instance, nor an object exposing a `readable` property. A `Blob`, a string or a
+ * `Uint8Array` must be wrapped in the matching Reader class, e.g. {@link BlobReader}, {@link TextReader}
+ * or {@link Uint8ArrayReader}.
+ */
+export const ERR_INVALID_READER: string;
 /**
  * Writer not initialized error
  */

package/index.d.ts

@@ -161,7 +161,7 @@
 /**
  * Represents the `FileSystemEntry` class.
  *
- * @see {@link https://wicg.github.io/entries-api/#api-entry|specification}
+ * @see {@link https://wicg.github.io/entries-api/#api-entry}
  */
 // deno-lint-ignore no-empty-interface
 interface FileSystemEntryLike {}
@@ -177,7 +177,7 @@ interface FileSystemHandleLike {}
 /**
  * Represents a generic `TransformStream` class.
  *
- * @see {@link https://streams.spec.whatwg.org/#generictransformstream|specification}
+ * @see {@link https://streams.spec.whatwg.org/#generictransformstream}
  */
 declare class TransformStreamLike {
   /**
@@ -1344,6 +1344,10 @@ export class ZipReaderStream<T> {
 
   /**
    * The readable stream.
+   *
+   * @remarks The properties deposited on an entry while its data is read, i.e.
+   * {@link EntryMetaData#warnings} and {@link EntryMetaData#localDirectory}, are shared with the
+   * chunk, so they are readable on it once its `readable` property has been consumed.
    */
   readable: ReadableStream<
     Omit<Entry, "getData"> & { readable?: ReadableStream<Uint8Array> }
@@ -1880,6 +1884,10 @@ export interface ZipReaderOptions {
   rawPassword?: Uint8Array;
   /**
    * The `AbortSignal` instance used to cancel the decompression.
+   *
+   * A signal already aborted when the operation starts rejects it with {@link ERR_ABORTED} as the
+   * reason of the `AbortError`, or with `signal.reason` when it is set, without relying on the
+   * `signal` option of `pipeTo` that the oldest supported engines ignore.
    */
   signal?: AbortSignal;
   /**
@@ -3027,6 +3035,8 @@ export interface ZipWriterCloseOptions extends EntryOnprogressOptions {
   /**
    * `true` to use Zip64 to write the entries directory.
    *
+   * Zip64 is also used when the directory does not fit in the standard record, or when an entry is stored with Zip64.
+   *
    * @defaultValue false
    */
   zip64?: boolean;
@@ -3059,6 +3069,8 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * `true` to use Zip64 to store the entry.
    *
    * `zip64` is automatically set to `true` when necessary (e.g. compressed data larger than 4GB or with unknown size).
+   * An entry of unknown size is stored with Zip64 in its local header, because the size of the data descriptor must be
+   * chosen before writing the data. Its central directory record drops Zip64 when the actual sizes fit in 32 bits.
    *
    * @defaultValue false
    */
@@ -3080,6 +3092,12 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * between platforms. Set `useCompressionStream` to `false` to get deterministic output across
    * platforms.
    *
+   * When no deflate implementation is available at all, i.e. the environment provides no usable
+   * `CompressionStream` and the embedded implementation cannot be loaded, the entry is stored
+   * instead of being compressed rather than failing. The {@link EntryMetaData#compressionMethod} of
+   * the entry returned by {@link ZipWriter#add} is `0` in that case, which is how the fallback is
+   * detected.
+   *
    * @defaultValue 6
    */
   level?: number;
@@ -3145,6 +3163,10 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
   encryptionStrength?: 1 | 2 | 3;
   /**
    * The `AbortSignal` instance used to cancel the compression.
+   *
+   * A signal already aborted when the operation starts rejects it with {@link ERR_ABORTED} as the
+   * reason of the `AbortError`, or with `signal.reason` when it is set, without relying on the
+   * `signal` option of `pipeTo` that the oldest supported engines ignore.
    */
   signal?: AbortSignal;
   /**
@@ -3389,6 +3411,8 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * boundaries and stored uncompressed unless the {@link ZipWriterConstructorOptions#level} or
    * {@link ZipWriterAddDataOptions#compressionMethod} options are set explicitly. Setting the
    * {@link ZipWriterConstructorOptions#password} option throws an {@link ERR_UNSUPPORTED_ENCRYPTION_USDZ} error.
+   * Writing into a split zip file throws an {@link ERR_UNSUPPORTED_SPLIT_USDZ} error, since the 64-byte alignment
+   * of an entry is invalidated when the disk it is written into rolls over.
    *
    * These constraints apply to the entries written with {@link ZipWriter#add} only. The entries copied with
    * {@link ZipWriter#appendZip} keep the layout of the source zip file and are not checked, so appending a
@@ -4634,6 +4658,10 @@ export const ERR_INVALID_ENCRYPTION_STRENGTH: string;
  * Unsupported encryption in USDZ files error
  */
 export const ERR_UNSUPPORTED_ENCRYPTION_USDZ: string;
+/**
+ * Unsupported split zip file in USDZ files error
+ */
+export const ERR_UNSUPPORTED_SPLIT_USDZ: string;
 /**
  * Unsupported encryption in pass-through entries error
  */
@@ -4728,6 +4756,15 @@ export const ERR_UNDETERMINED_SIZE: string;
  * is not there. Directory entries are exempt, they have no content to write as-is.
  */
 export const ERR_UNDEFINED_READER: string;
+/**
+ * Invalid reader error
+ *
+ * @remarks Thrown when the second argument of {@link ZipWriter#add} is neither a {@link Reader} instance, a
+ * `ReadableStream` instance, nor an object exposing a `readable` property. A `Blob`, a string or a
+ * `Uint8Array` must be wrapped in the matching Reader class, e.g. {@link BlobReader}, {@link TextReader}
+ * or {@link Uint8ArrayReader}.
+ */
+export const ERR_INVALID_READER: string;
 /**
  * Writer not initialized error
  */