@zip.js/zip.js 2.8.29 → 2.8.31

package/lib/core/zip-reader.js

@@ -82,7 +82,8 @@ import {
 	COMPRESSION_METHOD_DEFLATE_64,
 	FILE_ATTR_UNIX_SETUID_MASK,
 	FILE_ATTR_UNIX_SETGID_MASK,
-	FILE_ATTR_UNIX_STICKY_MASK
+	FILE_ATTR_UNIX_STICKY_MASK,
+	EMPTY_UINT8_ARRAY
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -138,6 +139,11 @@ import {
 	OPTION_CHECK_OVERLAPPING_ENTRY,
 	OPTION_CHECK_AMBIGUITY,
 	OPTION_CHECK_SIGNATURE,
+	OPTION_STRICTNESS,
+	OPTION_MAX_APPENDED_DATA_SIZE,
+	STRICTNESS_STRICT,
+	STRICTNESS_BALANCED,
+	STRICTNESS_TOLERANT,
 	OPTION_USE_WEB_WORKERS,
 	OPTION_USE_COMPRESSION_STREAM,
 	OPTION_TRANSFER_STREAMS,
@@ -159,8 +165,6 @@ const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 const CHARSET_CP437 = "cp437";
-// bits of the general purpose flag that change how an entry is interpreted; the level bits (1-2) are excluded
-// because they are informative only
 const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_LANG_ENCODING_FLAG;
 const ZIP64_PROPERTIES = [
 	[PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
@@ -202,8 +206,11 @@ class ZipReader {
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
-		reader.chunkSize = getChunkSize(config);
-		const endOfDirectoryInfo = await seekSignature(reader, END_OF_CENTRAL_DIR_SIGNATURE, reader.size, END_OF_CENTRAL_DIR_LENGTH, MAX_16_BITS * 16);
+		const strictness = getStrictness(getOptionValue(zipReader, options, OPTION_STRICTNESS), getOptionValue(zipReader, options, OPTION_CHECK_AMBIGUITY));
+		const checkAmbiguity = strictness == STRICTNESS_STRICT;
+		const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
+		const maxAppendedDataSize = getMaxAppendedDataSize(getOptionValue(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
+		const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
 		if (!endOfDirectoryInfo) {
 			const signatureArray = await readUint8Array(reader, 0, 4);
 			const signatureView = getDataView(signatureArray);
@@ -213,14 +220,16 @@ class ZipReader {
 				throw new Error(ERR_EOCDR_NOT_FOUND);
 			}
 		}
+		if (rejectAmbiguousEndOfDirectory && endOfDirectoryReachingEndCount > 1) {
+			throwAmbiguousArchive("multiple end of central directory records");
+		}
 		const endOfDirectoryView = getDataView(endOfDirectoryInfo);
 		let directoryDataLength = getUint32(endOfDirectoryView, 12);
 		let directoryDataOffset = getUint32(endOfDirectoryView, 16);
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
-		const checkAmbiguity = getOptionValue(zipReader, options, OPTION_CHECK_AMBIGUITY);
-		if (checkAmbiguity && appendedDataOffset != reader.size) {
+		if (reader.size - appendedDataOffset > maxAppendedDataSize) {
 			throwAmbiguousArchive("appended data");
 		}
 		let lastDiskNumber = getUint16(endOfDirectoryView, 4);
@@ -233,7 +242,7 @@ class ZipReader {
 		if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS) {
 			const endOfDirectoryLocatorArray = endOfDirectoryInfo.offset >= ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH ?
 				await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH) :
-				new Uint8Array();
+				EMPTY_UINT8_ARRAY;
 			const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
 			if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH &&
 				getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
@@ -299,14 +308,22 @@ class ZipReader {
 				throw new Error(ERR_BAD_FORMAT);
 			}
 			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength - (reader.lastDiskOffset || 0);
-			if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
-				const originalDirectoryDataOffset = directoryDataOffset;
-				directoryDataOffset = expectedDirectoryDataOffset;
-				if (directoryDataOffset > originalDirectoryDataOffset) {
-					prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
+			if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
+				const storedPointsAtDirectory = getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
+				let reconcile = !storedPointsAtDirectory;
+				if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
+					const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4, diskNumber);
+					reconcile = getUint32(getDataView(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
+				}
+				if (reconcile) {
+					const originalDirectoryDataOffset = directoryDataOffset;
+					directoryDataOffset = expectedDirectoryDataOffset;
+					if (directoryDataOffset > originalDirectoryDataOffset) {
+						prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
+					}
+					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
+					directoryView = getDataView(directoryArray);
 				}
-				directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
-				directoryView = getDataView(directoryArray);
 			}
 		}
 		const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset - (reader.lastDiskOffset || 0);
@@ -448,11 +465,11 @@ class ZipReader {
 		const extractPrependedData = getOptionValue(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 		const extractAppendedData = getOptionValue(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
 		if (extractPrependedData) {
-			zipReader.prependedData = startOffset > 0 ? await readUint8Array(reader, 0, startOffset) : new Uint8Array();
+			zipReader.prependedData = startOffset > 0 ? await readUint8Array(reader, 0, startOffset) : EMPTY_UINT8_ARRAY;
 		}
-		zipReader.comment = commentLength ? await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength) : new Uint8Array();
+		zipReader.comment = commentLength ? await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength) : EMPTY_UINT8_ARRAY;
 		if (extractAppendedData) {
-			zipReader.appendedData = appendedDataOffset < reader.size ? await readUint8Array(reader, appendedDataOffset, reader.size - appendedDataOffset) : new Uint8Array();
+			zipReader.appendedData = appendedDataOffset < reader.size ? await readUint8Array(reader, appendedDataOffset, reader.size - appendedDataOffset) : EMPTY_UINT8_ARRAY;
 		}
 		return true;
 	}
@@ -584,8 +601,8 @@ class ZipEntry {
 			extraFieldLength,
 			filenameLength
 		} = localDirectory;
-		const checkAmbiguity = getOptionValue(zipEntry, options, OPTION_CHECK_AMBIGUITY);
-		let rawLocalFilename = new Uint8Array();
+		const checkAmbiguity = getStrictness(getOptionValue(zipEntry, options, OPTION_STRICTNESS), getOptionValue(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
+		let rawLocalFilename = EMPTY_UINT8_ARRAY;
 		if (checkAmbiguity && (filenameLength || extraFieldLength)) {
 			const trailingDataArray = await readUint8Array(reader, offset + HEADER_SIZE, filenameLength + extraFieldLength, diskNumberStart);
 			rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
@@ -593,7 +610,7 @@ class ZipEntry {
 		} else {
 			localDirectory.rawExtraField = extraFieldLength ?
 				await readUint8Array(reader, offset + HEADER_SIZE + filenameLength, extraFieldLength, diskNumberStart) :
-				new Uint8Array();
+				EMPTY_UINT8_ARRAY;
 		}
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
 		if (checkAmbiguity) {
@@ -620,12 +637,7 @@ class ZipEntry {
 		}
 		const dataOffset = offset + HEADER_SIZE + filenameLength + extraFieldLength;
 		const size = compressedSize;
-		const readable = reader.readable;
-		Object.assign(readable, {
-			diskNumberStart,
-			offset: dataOffset,
-			size
-		});
+		const readable = reader.createReadable({ offset: dataOffset, size, diskNumberStart, chunkSize: getChunkSize(config) });
 		const signal = getOptionValue(zipEntry, options, OPTION_SIGNAL);
 		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 		let checkOverlappingEntry = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
@@ -896,7 +908,6 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 		const view = getDataView(new Uint8Array(extraField.data));
 		let uid, gid;
 		if (isInfoZip) {
-			// Info-ZIP New Unix "ux" field (0x7875): version + variable-length uid/gid
 			let offset = 0;
 			const version = getUint8(view, offset++);
 			const uidSize = getUint8(view, offset++);
@@ -906,8 +917,6 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 			gid = unpackUnixId(extraField.data.subarray(offset, offset + gidSize));
 			Object.assign(extraField, { version, uid, gid });
 		} else if (extraField.data.length >= 4) {
-			// Info-ZIP Unix "Ux" field (0x7855): fixed 2-byte uid + gid (the file mode, if any, is
-			// carried in the external file attributes, not here)
 			uid = getUint16(view, 0);
 			gid = getUint16(view, 2);
 			Object.assign(extraField, { uid, gid });
@@ -959,7 +968,6 @@ function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory,
 	timeProperties.forEach((propertyName, indexProperty) => {
 		if (extraFieldExtendedTimestamp.data.length >= offset + 4) {
 			const time = getUint32(extraFieldView, offset);
-			// the extended timestamp is a signed 32-bit time_t value
 			directory[propertyName] = extraFieldExtendedTimestamp[propertyName] = new Date((time | 0) * 1000);
 			const rawPropertyName = timeRawProperties[indexProperty];
 			extraFieldExtendedTimestamp[rawPropertyName] = time;
@@ -1034,26 +1042,133 @@ async function detectOverlappingEntry({
 	readRanges.set(index, range);
 }
 
-async function seekSignature(reader, signature, startOffset, minimumBytes, maximumLength) {
-	const signatureArray = new Uint8Array(4);
-	const signatureView = getDataView(signatureArray);
-	setUint32(signatureView, 0, signature);
-	const maximumBytes = minimumBytes + maximumLength;
-	return (await seek(minimumBytes)) || await seek(Math.min(maximumBytes, startOffset));
+function getStrictness(strictness, checkAmbiguity) {
+	if (strictness === UNDEFINED_VALUE) {
+		return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
+	}
+	return strictness;
+}
 
-	async function seek(length) {
-		const offset = startOffset - length;
-		const bytes = await readUint8Array(reader, offset, length);
-		for (let indexByte = bytes.length - minimumBytes; indexByte >= 0; indexByte--) {
-			if (bytes[indexByte] == signatureArray[0] && bytes[indexByte + 1] == signatureArray[1] &&
-				bytes[indexByte + 2] == signatureArray[2] && bytes[indexByte + 3] == signatureArray[3]) {
-				return {
-					offset: offset + indexByte,
-					buffer: bytes.slice(indexByte, indexByte + minimumBytes).buffer
-				};
+function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
+	if (maxAppendedDataSize !== UNDEFINED_VALUE) {
+		return maxAppendedDataSize;
+	}
+	if (strictness == STRICTNESS_STRICT) {
+		return 0;
+	}
+	if (strictness == STRICTNESS_TOLERANT) {
+		return Infinity;
+	}
+	return MAX_16_BITS;
+}
+
+const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
+
+const CENTRAL_DIRECTORY_UNREACHABLE = 0;
+const CENTRAL_DIRECTORY_PLAUSIBLE = 1;
+const CENTRAL_DIRECTORY_REACHABLE = 2;
+
+async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDataSize) {
+	const { size } = reader;
+	const anchoredLength = Math.min(size, END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS);
+	const remoteProbeBudget = { count: MAX_END_OF_CENTRAL_DIR_PROBES };
+	let endOfDirectoryInfo;
+	let plausibleEndOfDirectoryInfo;
+	let endOfDirectoryReachingEndCount = 0;
+	for await (const [anchoredView, anchoredOffset, anchoredArray, indexByte, offset] of scanEndOfCentralDirectory(reader, anchoredLength)) {
+		const commentLength = getUint16(anchoredView, indexByte + 20);
+		if (offset + END_OF_CENTRAL_DIR_LENGTH + commentLength == size) {
+			const reachability = await getCentralDirectoryReachability(reader, anchoredView, anchoredOffset, indexByte, offset, size, remoteProbeBudget);
+			if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
+				if (!endOfDirectoryInfo) {
+					endOfDirectoryInfo = getEndOfCentralDirectoryInfo(anchoredArray, indexByte, offset);
+				}
+				endOfDirectoryReachingEndCount++;
+				if (!rejectAmbiguous || endOfDirectoryReachingEndCount > 1) {
+					break;
+				}
+			} else if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleEndOfDirectoryInfo) {
+				plausibleEndOfDirectoryInfo = getEndOfCentralDirectoryInfo(anchoredArray, indexByte, offset);
 			}
 		}
 	}
+	if (!endOfDirectoryInfo) {
+		endOfDirectoryInfo = plausibleEndOfDirectoryInfo;
+	}
+	if (!endOfDirectoryInfo) {
+		endOfDirectoryInfo = await seekEndOfCentralDirectory(reader, maxAppendedDataSize, remoteProbeBudget);
+	}
+	return { endOfDirectoryInfo, endOfDirectoryReachingEndCount };
+}
+
+async function seekEndOfCentralDirectory(reader, maxAppendedDataSize, remoteProbeBudget) {
+	const { size } = reader;
+	const searchLength = Math.min(size, maxAppendedDataSize == Infinity ? size :
+		END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS + maxAppendedDataSize);
+	let firstSignatureInfo, plausibleInfo;
+	for await (const [searchView, searchOffset, searchArray, indexByte, offset] of scanEndOfCentralDirectory(reader, searchLength)) {
+		const record = getEndOfCentralDirectoryInfo(searchArray, indexByte, offset);
+		if (!firstSignatureInfo) {
+			firstSignatureInfo = record;
+		}
+		const reachability = await getCentralDirectoryReachability(reader, searchView, searchOffset, indexByte, offset, size, remoteProbeBudget);
+		if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
+			return record;
+		}
+		if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleInfo) {
+			plausibleInfo = record;
+		}
+	}
+	return plausibleInfo || firstSignatureInfo;
+}
+
+async function* scanEndOfCentralDirectory(reader, scanLength) {
+	const scanOffset = reader.size - scanLength;
+	const scanArray = await readUint8Array(reader, scanOffset, scanLength);
+	const scanView = getDataView(scanArray);
+	for (let indexByte = scanArray.length - END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
+		if (getUint32(scanView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
+			yield [scanView, scanOffset, scanArray, indexByte, scanOffset + indexByte];
+		}
+	}
+}
+
+function getEndOfCentralDirectoryInfo(scanArray, indexByte, offset) {
+	return { offset, buffer: scanArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer };
+}
+
+async function getCentralDirectoryReachability(reader, view, anchoredOffset, indexByte, offset, size, remoteProbeBudget) {
+	const filesLength = getUint16(view, indexByte + 10);
+	const directoryDataLength = getUint32(view, indexByte + 12);
+	const directoryDataOffset = getUint32(view, indexByte + 16);
+	if (filesLength == MAX_16_BITS || directoryDataLength == MAX_32_BITS || directoryDataOffset == MAX_32_BITS) {
+		const locatorSignature = await readSignature(reader, view, anchoredOffset, offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, size, remoteProbeBudget);
+		return locatorSignature == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE ? CENTRAL_DIRECTORY_REACHABLE : CENTRAL_DIRECTORY_UNREACHABLE;
+	}
+	if (!filesLength && !directoryDataLength) {
+		return CENTRAL_DIRECTORY_PLAUSIBLE;
+	}
+	for (const centralDirectoryOffset of [offset - directoryDataLength, directoryDataOffset]) {
+		if (await readSignature(reader, view, anchoredOffset, centralDirectoryOffset, size, remoteProbeBudget) == CENTRAL_FILE_HEADER_SIGNATURE) {
+			return CENTRAL_DIRECTORY_REACHABLE;
+		}
+	}
+	return CENTRAL_DIRECTORY_UNREACHABLE;
+}
+
+async function readSignature(reader, view, anchoredOffset, signatureOffset, size, remoteProbeBudget) {
+	if (signatureOffset < 0 || signatureOffset + 4 > size) {
+		return UNDEFINED_VALUE;
+	}
+	if (signatureOffset >= anchoredOffset) {
+		return getUint32(view, signatureOffset - anchoredOffset);
+	}
+	if (remoteProbeBudget.count > 0) {
+		remoteProbeBudget.count--;
+		const signatureArray = await readUint8Array(reader, signatureOffset, 4);
+		return getUint32(getDataView(signatureArray), 0);
+	}
+	return UNDEFINED_VALUE;
 }
 
 function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
@@ -1068,8 +1183,6 @@ function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
 	if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
 		throwAmbiguousArchive("mismatched local file header (compression method)");
 	}
-	// when the data descriptor flag is set, the local signature and sizes are zeroed out; all-zero values are
-	// also tolerated when the flag is clear because some tools produce them (streaming writers predating bit 3)
 	if (!localDirectory.bitFlag.dataDescriptor &&
 		(localDirectory.signature || localDirectory.compressedSize || localDirectory.uncompressedSize) &&
 		(localDirectory.signature != zipEntry.signature ||
@@ -1118,10 +1231,6 @@ function getBigUint64(view, offset) {
 	return Number(view.getBigUint64(offset, true));
 }
 
-function setUint32(view, offset, value) {
-	view.setUint32(offset, value, true);
-}
-
 function getDataView(array) {
 	return new DataView(array.buffer, array.byteOffset, array.byteLength);
 }

package/lib/core/zip-writer.js

@@ -137,7 +137,8 @@ import {
 	MAX_DATE,
 	UNDEFINED_VALUE,
 	INFINITY_VALUE,
-	OBJECT_TYPE
+	OBJECT_TYPE,
+	EMPTY_UINT8_ARRAY
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -218,7 +219,6 @@ const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
-// same message as the constant exported by zip-reader.js
 const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 const MIN_UNIX_TIME = -2147483648;
 const MAX_UNIX_TIME = 2147483647;
@@ -301,12 +301,12 @@ class ZipWriter {
 				rawExtraField,
 			} = entry;
 			const { level, languageEncodingFlag, dataDescriptor } = bitFlag;
-			rawExtraFieldZip64 = rawExtraFieldZip64 || new Uint8Array();
-			rawExtraFieldAES = rawExtraFieldAES || new Uint8Array();
-			rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || new Uint8Array();
-			rawExtraFieldNTFS = rawExtraFieldNTFS || new Uint8Array();
-			rawExtraFieldUnix = rawExtraFieldUnix || new Uint8Array();
-			rawExtraField = rawExtraField || new Uint8Array();
+			rawExtraFieldZip64 = rawExtraFieldZip64 || EMPTY_UINT8_ARRAY;
+			rawExtraFieldAES = rawExtraFieldAES || EMPTY_UINT8_ARRAY;
+			rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || EMPTY_UINT8_ARRAY;
+			rawExtraFieldNTFS = rawExtraFieldNTFS || EMPTY_UINT8_ARRAY;
+			rawExtraFieldUnix = rawExtraFieldUnix || EMPTY_UINT8_ARRAY;
+			rawExtraField = rawExtraField || EMPTY_UINT8_ARRAY;
 			if (entry.extraFieldAES) {
 				compressionMethod = COMPRESSION_METHOD_AES;
 			}
@@ -412,7 +412,7 @@ class ZipWriter {
 		return false;
 	}
 
-	async close(comment = new Uint8Array(), options = {}) {
+	async close(comment = EMPTY_UINT8_ARRAY, options = {}) {
 		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
@@ -728,7 +728,7 @@ function resolveMetadata(zipWriter, name, options) {
 	if (!zipCrypto && (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) && !(encryptionStrength >= 1 && encryptionStrength <= 3)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
-	let rawExtraField = new Uint8Array();
+	let rawExtraField = EMPTY_UINT8_ARRAY;
 	const extraField = options[PROPERTY_NAME_EXTRA_FIELD];
 	if (extraField) {
 		let extraFieldSize = 0;
@@ -789,8 +789,6 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	let maximumCompressedSize = 0;
 	let uncompressedSize = 0;
 	if (passThrough) {
-		// the headers of a passThrough entry describe the payload verbatim: without a
-		// reader they would declare content that is not there
 		if (!reader) {
 			throw new Error(ERR_UNDEFINED_READER);
 		}
@@ -801,8 +799,6 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	}
 	const zip64Enabled = zip64 === true;
 	const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
-	// entries without a reader have no payload: write them as empty stored files instead of
-	// declaring a compressed or encrypted content that does not exist
 	const encryptedEntry = Boolean(reader) && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
 	if (!reader) {
 		level = 0;
@@ -940,7 +936,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			fileEntry.diskNumberStart = writer.diskNumber;
 			fileEntry.offset = getSegmentOffset(zipWriter, writer);
 			if (usdz) {
-				// the padding depends on the entry offset, only known now that the writer is locked
 				const previousMetadataSize = entryInfo.metadataSize;
 				appendExtraFieldUSDZ(entryInfo, zipWriter.offset - writer.diskOffset);
 				fileEntry.size += entryInfo.metadataSize - previousMetadataSize;
@@ -983,6 +978,13 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		if (releaseLockWriter) {
 			releaseLockWriter();
 		}
+		if (bufferedWrite && fileWriter && fileWriter.dispose) {
+			try {
+				await fileWriter.dispose();
+			} catch {
+				// ignored
+			}
+		}
 	}
 
 	function requestLockCurrentFileEntry() {
@@ -1002,7 +1004,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	async function skipDiskIfNeeded() {
 		if (getLength(headerInfo.localHeaderArray) > writer.availableSize) {
 			writer.availableSize = 0;
-			await writeData(writer, new Uint8Array());
+			await writeData(writer, EMPTY_UINT8_ARRAY);
 		}
 	}
 }
@@ -1113,8 +1115,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	}
 	const { writable } = writer;
 	if (reader) {
-		reader.chunkSize = getChunkSize(config);
-		const readable = reader.readable;
+		const readable = reader.createReadable ? reader.createReadable({ chunkSize: getChunkSize(config) }) : reader.readable;
 		const size = reader.size;
 		const workerOptions = {
 			options: {
@@ -1214,13 +1215,9 @@ function getHeaderInfo(options) {
 		: compressionMethod !== COMPRESSION_METHOD_STORE);
 	let rawLocalExtraFieldZip64;
 	const uncompressedFile = passThrough || !compressed;
-	// entries without a data descriptor are always buffered (cf. getFileEntry), so the
-	// zip64 extra field values can be patched into the local header before flushing it
 	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
 	const writeLocalExtraFieldZip64 = zip64ExtraFieldComplete || (zip64 && dataDescriptor && (zip64UncompressedSize || zip64CompressedSize));
 	if (zip64 && (zip64UncompressedSize || zip64CompressedSize)) {
-		// APPNOTE 4.5.3: the zip64 extra field of a local header must include both the
-		// uncompressed and compressed size fields
 		const length = 4 + 16;
 		const extraFieldZip64 = createRecordWriter(length);
 		extraFieldZip64.uint16(EXTRAFIELD_TYPE_ZIP64);
@@ -1234,7 +1231,7 @@ function getHeaderInfo(options) {
 			}
 		}
 	} else {
-		rawLocalExtraFieldZip64 = new Uint8Array();
+		rawLocalExtraFieldZip64 = EMPTY_UINT8_ARRAY;
 	}
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
@@ -1244,7 +1241,7 @@ function getHeaderInfo(options) {
 		rawExtraFieldAES = extraFieldAES.array;
 		rawExtraFieldAES[8] = encryptionStrength;
 	} else {
-		rawExtraFieldAES = new Uint8Array();
+		rawExtraFieldAES = EMPTY_UINT8_ARRAY;
 	}
 	let rawExtraFieldNTFS;
 	let rawExtraFieldExtendedTimestamp;
@@ -1267,8 +1264,7 @@ function getHeaderInfo(options) {
 			}
 			rawExtraFieldExtendedTimestamp = extraFieldTimestamp.array;
 		} else {
-			// the date cannot be stored as a 32-bit time_t; the NTFS field replaces it
-			rawExtraFieldExtendedTimestamp = new Uint8Array();
+			rawExtraFieldExtendedTimestamp = EMPTY_UINT8_ARRAY;
 		}
 		try {
 			const lastModTimeNTFS = getTimeNTFS(lastModDate);
@@ -1283,10 +1279,10 @@ function getHeaderInfo(options) {
 			extraFieldNTFS.uint64(getTimeNTFS(creationDate) || lastModTimeNTFS);
 			rawExtraFieldNTFS = extraFieldNTFS.array;
 		} catch {
-			rawExtraFieldNTFS = new Uint8Array();
+			rawExtraFieldNTFS = EMPTY_UINT8_ARRAY;
 		}
 	} else {
-		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
+		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = EMPTY_UINT8_ARRAY;
 	}
 	let rawExtraFieldUnix;
 	try {
@@ -1312,10 +1308,10 @@ function getHeaderInfo(options) {
 			extraFieldUnix.uint16((gid === UNDEFINED_VALUE ? 0 : gid) & MAX_16_BITS);
 			rawExtraFieldUnix = extraFieldUnix.array;
 		} else {
-			rawExtraFieldUnix = new Uint8Array();
+			rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
 		}
 	} catch {
-		rawExtraFieldUnix = new Uint8Array();
+		rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
 	}
 	if (compressionMethod === UNDEFINED_VALUE) {
 		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
@@ -1382,7 +1378,7 @@ function getHeaderInfo(options) {
 		version,
 		compressionMethod,
 		extraFieldExtendedTimestampFlag,
-		rawExtraFieldZip64: new Uint8Array(),
+		rawExtraFieldZip64: EMPTY_UINT8_ARRAY,
 		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
@@ -1395,7 +1391,6 @@ function getHeaderInfo(options) {
 function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	const { headerInfo } = entryInfo;
 	let { localHeaderArray, extraFieldLength } = headerInfo;
-	let localHeaderArrayView;
 	let extraBytesLength = 64 - ((zipWriterOffset + getLength(localHeaderArray)) % 64);
 	if (extraBytesLength < 4) {
 		extraBytesLength += 64;
@@ -1408,7 +1403,7 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	headerInfo.localHeaderArray = localHeaderArray = new Uint8Array(getLength(previousLocalHeaderArray) + extraBytesLength);
 	arraySet(localHeaderArray, previousLocalHeaderArray);
 	arraySet(localHeaderArray, rawExtraFieldUSDZ, getLength(previousLocalHeaderArray));
-	localHeaderArrayView = getDataView(localHeaderArray);
+	const localHeaderArrayView = getDataView(localHeaderArray);
 	setUint16(localHeaderArrayView, 28, extraFieldLength + extraBytesLength);
 	headerInfo.localHeaderView = localHeaderArrayView;
 	entryInfo.metadataSize += extraBytesLength;
@@ -1416,7 +1411,7 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 
 function packUnixId(id) {
 	if (id === UNDEFINED_VALUE) {
-		return new Uint8Array();
+		return EMPTY_UINT8_ARRAY;
 	} else {
 		const dataArray = new Uint8Array(4);
 		const dataView = getDataView(dataArray);
@@ -1459,7 +1454,7 @@ function getDataDescriptorInfo({
 	dataDescriptor,
 	dataDescriptorSignature
 }) {
-	let dataDescriptorArray = new Uint8Array();
+	let dataDescriptorArray = EMPTY_UINT8_ARRAY;
 	let dataDescriptorView, dataDescriptorOffset = 0;
 	let dataDescriptorLength = zip64 ? DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH : DATA_DESCRIPTOR_RECORD_LENGTH;
 	if (dataDescriptorSignature) {
@@ -1543,7 +1538,6 @@ function updateLocalHeader({
 		}
 	}
 	if (zip64 && localExtraFieldZip64Length) {
-		// the local zip64 extra field always contains both size slots
 		const localHeaderOffset = HEADER_SIZE + getLength(rawFilename) + 4;
 		setBigUint64(localHeaderView, localHeaderOffset, BigInt(uncompressedSize));
 		setBigUint64(localHeaderView, localHeaderOffset + 8, BigInt(compressedSize));
@@ -1597,7 +1591,7 @@ function createDirectoryRecords(files) {
 			}
 			rawExtraFieldZip64 = extraFieldZip64.array;
 		} else {
-			rawExtraFieldZip64 = new Uint8Array();
+			rawExtraFieldZip64 = EMPTY_UINT8_ARRAY;
 		}
 		fileEntry.rawExtraFieldZip64 = rawExtraFieldZip64;
 		fileEntry.zip64Offset = zip64Offset;
@@ -1612,7 +1606,7 @@ function createDirectoryRecords(files) {
 			extraFieldTimestamp.uint32(lastModTimeUnix);
 			rawExtraFieldTimestamp = extraFieldTimestamp.array;
 		} else {
-			rawExtraFieldTimestamp = new Uint8Array();
+			rawExtraFieldTimestamp = EMPTY_UINT8_ARRAY;
 		}
 		fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
 		const extraFieldLength = getLength(
@@ -1668,7 +1662,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
 			directoryDiskOffset = offset;
 			writer.availableSize = 0;
-			await writeData(writer, new Uint8Array());
+			await writeData(writer, EMPTY_UINT8_ARRAY);
 		}
 		if (indexFileEntry == 0) {
 			cdStartDiskNumber = writer.diskNumber;
@@ -1741,7 +1735,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	const endOfdirectoryRecord = createRecordWriter(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 	if (getLength(endOfdirectoryRecord.array) + commentLength > writer.availableSize) {
 		writer.availableSize = 0;
-		await writeData(writer, new Uint8Array());
+		await writeData(writer, EMPTY_UINT8_ARRAY);
 	}
 	lastDiskNumber = writer.diskNumber;
 	if (zip64) {
@@ -1838,7 +1832,6 @@ function getTimeUnix(date) {
 	return Math.floor(date.getTime() / 1000);
 }
 
-// the extended timestamp extra field stores dates as signed 32-bit time_t values
 function inUnixTimeRange(timeUnix) {
 	return timeUnix >= MIN_UNIX_TIME && timeUnix <= MAX_UNIX_TIME;
 }

package/lib/core/zlib-streams-inline-template.js

@@ -28,7 +28,8 @@
 
 /* eslint-disable quotes */
 
-import { decompress } from "./util/mini-lz.js";
+import { inflateRaw } from "./util/inflate.js";
+import { base64Decode, base64Encode } from "./util/base64.js";
 
 export function configureZlibModule(configure) {
 	const data = `__wasmBinary__`;
@@ -36,7 +37,7 @@ export function configureZlibModule(configure) {
 	configure({
 		wasmURI: () => {
 			if (!dataURI) {
-				dataURI = "data:application/wasm;base64," + decompress(data);
+				dataURI = "data:application/wasm;base64," + base64Encode(inflateRaw(base64Decode(data)));
 			}
 			return dataURI;
 		}