@zip.js/zip.js 2.8.29 → 2.8.31

package/dist/zip-core.js

@@ -113,6 +113,8 @@
 	const FUNCTION_TYPE = "function";
 	const OBJECT_TYPE = "object";
 
+	const EMPTY_UINT8_ARRAY = new Uint8Array();
+
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -164,6 +166,22 @@
 		DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 	};
 
+	const CONFIGURABLE_PROPERTY_NAMES = [
+		"baseURI",
+		"wasmURI",
+		"workerURI",
+		"chunkSize",
+		"maxWorkers",
+		"terminateWorkerTimeout",
+		"workerStarvationTimeout",
+		"useCompressionStream",
+		"useWebWorkers",
+		"CompressionStream",
+		"DecompressionStream",
+		"CompressionStreamZlib",
+		"DecompressionStreamZlib"
+	];
+
 	const config = Object.assign({}, DEFAULT_CONFIGURATION);
 
 	function getConfiguration() {
@@ -175,39 +193,11 @@
 	}
 
 	function configure(configuration) {
-		const {
-			baseURI,
-			chunkSize,
-			maxWorkers,
-			terminateWorkerTimeout,
-			workerStarvationTimeout,
-			useCompressionStream,
-			useWebWorkers,
-			CompressionStream,
-			DecompressionStream,
-			CompressionStreamZlib,
-			DecompressionStreamZlib,
-			workerURI,
-			wasmURI
-		} = configuration;
-		setIfDefined("baseURI", baseURI);
-		setIfDefined("wasmURI", wasmURI);
-		setIfDefined("workerURI", workerURI);
-		setIfDefined("chunkSize", chunkSize);
-		setIfDefined("maxWorkers", maxWorkers);
-		setIfDefined("terminateWorkerTimeout", terminateWorkerTimeout);
-		setIfDefined("workerStarvationTimeout", workerStarvationTimeout);
-		setIfDefined("useCompressionStream", useCompressionStream);
-		setIfDefined("useWebWorkers", useWebWorkers);
-		setIfDefined("CompressionStream", CompressionStream);
-		setIfDefined("DecompressionStream", DecompressionStream);
-		setIfDefined("CompressionStreamZlib", CompressionStreamZlib);
-		setIfDefined("DecompressionStreamZlib", DecompressionStreamZlib);
-	}
-
-	function setIfDefined(propertyName, propertyValue) {
-		if (propertyValue !== UNDEFINED_VALUE) {
-			config[propertyName] = propertyValue;
+		for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
+			const propertyValue = configuration[propertyName];
+			if (propertyValue !== UNDEFINED_VALUE) {
+				config[propertyName] = propertyValue;
+			}
 		}
 	}
 
@@ -239,18 +229,30 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const table = [];
-	for (let i = 0; i < 256; i++) {
-		let t = i;
+	// Slicing-by-8 CRC-32 (Intel / zlib). The eight 256-entry tables let the inner loop
+	// consume 8 bytes per iteration with a shorter dependency chain, ~4x the byte-at-a-time
+	// rate (measured ~320 -> ~1400 MB/s on 64KB chunks).
+	//
+	// Every table MUST stay a PACKED_SMI array: build with array literals (not `new Array(n)`,
+	// which is HOLEY) and store the signed int32 XOR result (no `>>> 0`). An unsigned or holey
+	// table becomes a V8 FixedDoubleArray whose every hot-loop lookup unboxes a double (~1.6x
+	// slower). Signedness is irrelevant to the result — the reads mask/shift it and the final
+	// `~crc` normalizes it. Do NOT reintroduce `>>> 0` here or switch to `new Array(256)`.
+	const T = [[], [], [], [], [], [], [], []];
+	for (let n = 0; n < 256; n++) {
+		let t = n;
 		for (let j = 0; j < 8; j++) {
-			if (t & 1) {
-				t = (t >>> 1) ^ 0xEDB88320;
-			} else {
-				t = t >>> 1;
-			}
+			t = (t & 1) ? (t >>> 1) ^ 0xEDB88320 : t >>> 1;
 		}
-		table[i] = t;
+		T[0][n] = t;
 	}
+	for (let n = 0; n < 256; n++) {
+		for (let k = 1; k < 8; k++) {
+			const previous = T[k - 1][n];
+			T[k][n] = (previous >>> 8) ^ T[0][previous & 0xFF];
+		}
+	}
+	const [T0, T1, T2, T3, T4, T5, T6, T7] = T;
 
 	class Crc32 {
 
@@ -260,8 +262,24 @@
 
 		append(data) {
 			let crc = this.crc | 0;
-			for (let offset = 0, length = data.length | 0; offset < length; offset++) {
-				crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
+			const length = data.length | 0;
+			let offset = 0;
+			// Process 8 bytes per iteration over the typed-array body. DataView.getInt32(le)
+			// reads an unaligned little-endian word as a signed int32 (no double boxing), so no
+			// alignment or endianness handling is needed; data.buffer guards non-typed inputs.
+			if (length >= 8 && data.buffer) {
+				const view = new DataView(data.buffer, data.byteOffset, length);
+				const end = length - 8;
+				for (; offset <= end; offset += 8) {
+					const a = crc ^ view.getInt32(offset, true);
+					const b = view.getInt32(offset + 4, true);
+					crc = T7[a & 0xFF] ^ T6[(a >>> 8) & 0xFF] ^ T5[(a >>> 16) & 0xFF] ^ T4[(a >>> 24) & 0xFF] ^
+						T3[b & 0xFF] ^ T2[(b >>> 8) & 0xFF] ^ T1[(b >>> 16) & 0xFF] ^ T0[(b >>> 24) & 0xFF];
+				}
+			}
+			// Remaining tail (and non-typed inputs) byte-at-a-time with the base table.
+			for (; offset < length; offset++) {
+				crc = (crc >>> 8) ^ T0[(crc ^ data[offset]) & 0xFF];
 			}
 			this.crc = crc;
 		}
@@ -1194,8 +1212,6 @@
 		if (GET_RANDOM_VALUES_SUPPORTED) {
 			return crypto.getRandomValues(array);
 		} else {
-			// all supported runtimes expose crypto.getRandomValues; failing hard beats
-			// silently generating predictable encryption salts
 			throw new Error(ERR_UNSUPPORTED_CRYPTO_API);
 		}
 	}
@@ -1258,12 +1274,7 @@
 		constructor({ password, rawPassword, encryptionStrength, checkPasswordOnly }) {
 			super({
 				start() {
-					Object.assign(this, {
-						ready: new Promise(resolve => this.resolveReady = resolve),
-						password: encodePassword(password, rawPassword),
-						strength: encryptionStrength - 1,
-						pending: new Uint8Array()
-					});
+					initAesCrypto(this, password, rawPassword, encryptionStrength);
 				},
 				async transform(chunk, controller) {
 					const aesCrypto = this;
@@ -1298,7 +1309,7 @@
 						await ready;
 						const chunkToDecrypt = subarray(pending, 0, pending.length - SIGNATURE_LENGTH);
 						const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
-						let decryptedChunkArray = new Uint8Array();
+						let decryptedChunkArray = EMPTY_UINT8_ARRAY;
 						if (chunkToDecrypt.length) {
 							const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
 							hmac.update(encryptedChunk);
@@ -1306,8 +1317,6 @@
 							decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
 						}
 						const signature = subarray(fromBits(codecBytes, hmac.digest()), 0, SIGNATURE_LENGTH);
-						// branch-free comparison: accumulate the differences instead of
-						// short-circuiting on the first mismatching byte
 						let invalidSignature = pending.length < SIGNATURE_LENGTH ? 1 : 0;
 						for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
 							invalidSignature |= signature[indexSignature] ^ originalSignature[indexSignature];
@@ -1329,12 +1338,7 @@
 			let stream;
 			super({
 				start() {
-					Object.assign(this, {
-						ready: new Promise(resolve => this.resolveReady = resolve),
-						password: encodePassword(password, rawPassword),
-						strength: encryptionStrength - 1,
-						pending: new Uint8Array()
-					});
+					initAesCrypto(this, password, rawPassword, encryptionStrength);
 				},
 				async transform(chunk, controller) {
 					const aesCrypto = this;
@@ -1344,7 +1348,7 @@
 						resolveReady,
 						ready
 					} = aesCrypto;
-					let preamble = new Uint8Array();
+					let preamble = EMPTY_UINT8_ARRAY;
 					if (password) {
 						preamble = await createEncryptionKeys(aesCrypto, strength, password);
 						resolveReady();
@@ -1364,7 +1368,7 @@
 					} = this;
 					if (hmac && ctr) {
 						await ready;
-						let encryptedChunkArray = new Uint8Array();
+						let encryptedChunkArray = EMPTY_UINT8_ARRAY;
 						if (pending.length) {
 							const encryptedChunk = ctr.update(toBits(codecBytes, pending));
 							hmac.update(encryptedChunk);
@@ -1379,6 +1383,15 @@
 		}
 	}
 
+	function initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength) {
+		Object.assign(aesCrypto, {
+			ready: new Promise(resolve => aesCrypto.resolveReady = resolve),
+			password: encodePassword(password, rawPassword),
+			strength: encryptionStrength - 1,
+			pending: EMPTY_UINT8_ARRAY
+		});
+	}
+
 	function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignature) {
 		const {
 			ctr,
@@ -1540,20 +1553,13 @@
 		constructor({ password, rawPassword, passwordVerification, checkPasswordOnly }) {
 			super({
 				start() {
-					Object.assign(this, {
-						password,
-						rawPassword,
-						passwordVerification
-					});
-					createKeys(this, password, rawPassword);
+					initZipCrypto(this, password, rawPassword, passwordVerification);
 				},
 				transform(chunk, controller) {
 					const zipCrypto = this;
 					if (zipCrypto.password || zipCrypto.rawPassword) {
 						const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
 						zipCrypto.password = zipCrypto.rawPassword = null;
-						// verify the password with a branch-free comparison of the verification byte, mirroring
-						// the constant-time AES HMAC signature check
 						if ((decryptedHeader.at(-1) ^ zipCrypto.passwordVerification) != 0) {
 							throw new Error(ERR_INVALID_PASSWORD);
 						}
@@ -1574,12 +1580,7 @@
 		constructor({ password, rawPassword, passwordVerification }) {
 			super({
 				start() {
-					Object.assign(this, {
-						password,
-						rawPassword,
-						passwordVerification
-					});
-					createKeys(this, password, rawPassword);
+					initZipCrypto(this, password, rawPassword, passwordVerification);
 				},
 				transform(chunk, controller) {
 					const zipCrypto = this;
@@ -1603,6 +1604,15 @@
 		}
 	}
 
+	function initZipCrypto(zipCrypto, password, rawPassword, passwordVerification) {
+		Object.assign(zipCrypto, {
+			password,
+			rawPassword,
+			passwordVerification
+		});
+		createKeys(zipCrypto, password, rawPassword);
+	}
+
 	function decrypt(target, input) {
 		const output = new Uint8Array(input.length);
 		for (let index = 0; index < input.length; index++) {
@@ -1695,21 +1705,32 @@
 	const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
 	const FORMAT_DEFLATE_RAW = "deflate-raw";
 	const FORMAT_DEFLATE64_RAW = "deflate64-raw";
+	const FORMAT_GZIP = "gzip";
+	const GZIP_HEADER_LENGTH = 10;
+	const GZIP_TRAILER_LENGTH = 8;
 
 	class DeflateStream extends TransformStream {
 
 		constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
 			super({});
-			const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level } = options;
+			const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level, deflate64 } = options;
 			const stream = this;
-			let crc32Stream, encryptionStream;
+			let crc32Stream, encryptionStream, gzipCrc32Stream;
 			let readable = super.readable;
-			if ((!encrypted || zipCrypto) && signed) {
+			const useGzipCrc32 = signed && compressed && !deflate64 && (!encrypted || zipCrypto) &&
+				Boolean(useCompressionStream && CompressionStream);
+			if ((!encrypted || zipCrypto) && signed && !useGzipCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
 			}
 			if (compressed) {
-				readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib, CompressionStream);
+				if (useGzipCrc32) {
+					gzipCrc32Stream = new GzipToRawDeflateStream();
+					readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP));
+					readable = pipeThrough(readable, gzipCrc32Stream);
+				} else {
+					readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib, CompressionStream);
+				}
 			}
 			if (encrypted) {
 				if (zipCrypto) {
@@ -1725,13 +1746,64 @@
 					signature = encryptionStream.signature;
 				}
 				if ((!encrypted || zipCrypto) && signed) {
-					signature = new DataView(crc32Stream.value.buffer).getUint32(0);
+					signature = useGzipCrc32 ? gzipCrc32Stream.signature : new DataView(crc32Stream.value.buffer).getUint32(0);
 				}
 				stream.signature = signature;
 			});
 		}
 	}
 
+	class GzipToRawDeflateStream extends TransformStream {
+
+		constructor() {
+			// deno-lint-ignore prefer-const
+			let stream;
+			let headerLeft = GZIP_HEADER_LENGTH;
+			let tail = new Uint8Array(0);
+			super({
+				transform(chunk, controller) {
+					if (headerLeft) {
+						const dropped = Math.min(headerLeft, chunk.length);
+						headerLeft -= dropped;
+						chunk = chunk.subarray(dropped);
+						if (!chunk.length) {
+							return;
+						}
+					}
+					const available = tail.length + chunk.length;
+					if (available <= GZIP_TRAILER_LENGTH) {
+						const pending = new Uint8Array(available);
+						pending.set(tail);
+						pending.set(chunk, tail.length);
+						tail = pending;
+						return;
+					}
+					const emitLength = available - GZIP_TRAILER_LENGTH;
+					const output = new Uint8Array(emitLength);
+					const fromTail = Math.min(emitLength, tail.length);
+					output.set(tail.subarray(0, fromTail), 0);
+					if (emitLength > fromTail) {
+						output.set(chunk.subarray(0, emitLength - fromTail), fromTail);
+					}
+					controller.enqueue(output);
+					const nextTail = new Uint8Array(GZIP_TRAILER_LENGTH);
+					const tailRemaining = tail.length - fromTail;
+					if (tailRemaining) {
+						nextTail.set(tail.subarray(fromTail), 0);
+					}
+					nextTail.set(chunk.subarray(emitLength - fromTail), tailRemaining);
+					tail = nextTail;
+				},
+				flush() {
+					const dataView = new DataView(tail.buffer, tail.byteOffset, tail.byteLength);
+					stream.signature = dataView.getUint32(0, true);
+					stream.uncompressedSize = dataView.getUint32(4, true);
+				}
+			});
+			stream = this;
+		}
+	}
+
 	class InflateStream extends TransformStream {
 
 		constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
@@ -1794,11 +1866,6 @@
 				throw error;
 			}
 		}
-		// The native CompressionStream/DecompressionStream and the pure-JS zlib port do not signal
-		// backpressure on their writable side (their `ready` never pends), so a plain pipeThrough drains
-		// the whole source into them and peak memory grows with the entry size. Awaiting each write()
-		// paces the source to the codec's consumption rate, keeping streaming memory bounded. The WASM
-		// codec already backpressures, so this is a no-op cost for it.
 		return pipeThroughBackpressured(readable, codecStream);
 	}
 
@@ -1806,10 +1873,6 @@
 		return readable.pipeThrough(transformStream);
 	}
 
-	// Like readable.pipeThrough(transformStream), but drives the writable side manually and awaits each
-	// write() so that a codec which under-reports backpressure cannot pull the whole source into memory.
-	// Errors propagate in both directions: a source error aborts the codec; a downstream cancel/error
-	// (surfaced through the codec's writable rejecting) cancels the source.
 	function pipeThroughBackpressured(readable, transformStream) {
 		const writer = transformStream.writable.getWriter();
 		const reader = readable.getReader();
@@ -1838,7 +1901,7 @@
 		try {
 			await writer.abort(error);
 		} catch {
-			// the writable may already be errored/closed
+			// ignored: the writable may already be errored/closed
 		}
 	}
 
@@ -1846,13 +1909,10 @@
 		try {
 			await reader.cancel(error);
 		} catch {
-			// the readable may already be errored/closed
+			// ignored: the readable may already be errored/closed
 		}
 	}
 
-	// DecompressionStream implementations can fail with a message-less TypeError on malformed
-	// input; give these errors an identifiable message (errors raised by the other stages of
-	// the pipeline, e.g. ERR_INVALID_PASSWORD, always carry a message and pass through as-is)
 	function mapInflateStreamError(readable) {
 		const reader = readable.getReader();
 		return new ReadableStream({
@@ -2177,9 +2237,6 @@
 				try {
 					await initModule(config);
 				} catch {
-					// The WASM module failed to load. Fall back to the native CompressionStream only if the
-					// zlib codec that would otherwise run depends on that module; a self-contained codec
-					// supplied through config (e.g. the pure-JS port) stays usable and is kept as requested.
 					const ZlibStream = options.codecType.startsWith(CODEC_DEFLATE) ?
 						config.CompressionStreamZlib :
 						config.DecompressionStreamZlib;
@@ -2257,7 +2314,6 @@
 			return resultValue;
 		} catch (error) {
 			await closeWritable();
-			// unblock the pipe watcher if the worker died before closing its end of the stream
 			abortPipe();
 			try {
 				await closed;
@@ -2282,8 +2338,6 @@
 		const abortController = new AbortController();
 		const { writable, readable } = new TransformStream();
 		const closed = readable.pipeTo(writableSource, { preventClose: true, preventAbort: true, signal: abortController.signal });
-		// the pipe can fail before `closed` is awaited (e.g. the destination write fails);
-		// mark the rejection as handled so it cannot kill the process in the meantime
 		closed.catch(() => { });
 		return { writable, closed, abortPipe: () => abortController.abort() };
 	}
@@ -2376,8 +2430,6 @@
 			event.preventDefault();
 		}
 		const { rejectResult, writer, onTaskFinished } = workerData;
-		// the worker is unusable (e.g. its script failed to load); terminate it and
-		// fail the current task instead of letting it hang forever
 		terminateWorker$1(workerData);
 		if (rejectResult) {
 			rejectResult(event.error || new Error(event.message || ERROR_EVENT_TYPE));
@@ -2429,8 +2481,6 @@
 	async function onMessage({ data }, workerData) {
 		const { type, value, messageId, result, error } = data;
 		const { reader, writer, resolveResult, rejectResult, onTaskFinished, generation } = workerData;
-		// continuations below can settle after the worker slot has been reassigned to a new
-		// task (e.g. a pending pull read failing late); they must not touch the new task
 		const stale = () => workerData.generation != generation;
 		try {
 			if (error) {
@@ -2686,26 +2736,24 @@
 	class Reader extends Stream {
 
 		get readable() {
+			return this.createReadable();
+		}
+
+		createReadable({ offset = 0, size, diskNumberStart, chunkSize = DEFAULT_CHUNK_SIZE } = {}) {
 			const reader = this;
-			const { chunkSize = DEFAULT_CHUNK_SIZE } = reader;
-			const readable = new ReadableStream({
-				start() {
-					this.chunkOffset = 0;
-				},
+			let chunkOffset = 0;
+			return new ReadableStream({
 				async pull(controller) {
-					const { offset = 0, size, diskNumberStart } = readable;
-					const { chunkOffset } = this;
 					const dataSize = size === UNDEFINED_VALUE ? chunkSize : Math.min(chunkSize, size - chunkOffset);
 					const data = await readUint8Array(reader, offset + chunkOffset, dataSize, diskNumberStart);
 					controller.enqueue(data);
 					if ((chunkOffset + chunkSize > size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
 						controller.close();
 					} else {
-						this.chunkOffset += chunkSize;
+						chunkOffset += chunkSize;
 					}
 				}
 			});
-			return readable;
 		}
 	}
 
@@ -2844,8 +2892,6 @@
 				}
 			});
 			writer.blob = new Response(transformStream.readable, { headers }).blob();
-			// mark early rejections (e.g. aborted pipe) as handled; awaiting getData() still
-			// surfaces them
 			writer.blob.catch(() => { });
 		}
 
@@ -3007,7 +3053,7 @@
 				return eocdCache;
 			}
 			if (index >= size || length === 0) {
-				return new Uint8Array();
+				return EMPTY_UINT8_ARRAY;
 			} else {
 				if (index + length > size) {
 					length = size - index;
@@ -3064,8 +3110,6 @@
 	async function getRequestData(httpReader, sendRequest) {
 		const response = await sendRequest(HTTP_METHOD_GET, httpReader, getHeaders(httpReader));
 		httpReader.data = new Uint8Array(await response.arrayBuffer());
-		// the downloaded content is authoritative, e.g. the Content-Length response header
-		// of the HEAD request can be the encoded size when the content is compressed
 		httpReader.size = httpReader.data.length;
 	}
 
@@ -3130,7 +3174,6 @@
 			super();
 			Object.assign(this, {
 				url,
-				// an explicit fetch implementation takes precedence over useXHR
 				reader: options.useXHR && !options.fetch ? new XHRReader(url, options) : new FetchReader(url, options)
 			});
 		}
@@ -3269,7 +3312,7 @@
 					}
 				}
 			} else {
-				result = new Uint8Array();
+				result = EMPTY_UINT8_ARRAY;
 			}
 			reader.lastDiskNumber = Math.max(currentDiskNumber, reader.lastDiskNumber);
 			return result;
@@ -3314,8 +3357,6 @@
 						writer.diskOffset += diskSourceWriter.size;
 						writer.diskNumber++;
 						diskWriter = null;
-						// the next disk is not opened yet but its space is available; leaving a
-						// stale value here would force a new disk for every subsequent write
 						writer.availableSize = writer.maxSize;
 						if (chunk.length > availableSize) {
 							await this.write(chunk.subarray(availableSize));
@@ -3495,7 +3536,6 @@
 		if (encoding && encoding.trim().toLowerCase() == "cp437") {
 			return decodeCP437(value);
 		} else {
-			// ignoreBOM keeps a leading U+FEFF in filenames/comments instead of dropping it
 			return new TextDecoder(encoding, { ignoreBOM: true }).decode(value);
 		}
 	}
@@ -3693,6 +3733,11 @@
 	const OPTION_OFFSET = "offset";
 	const OPTION_USDZ = "usdz";
 	const OPTION_UNIX_EXTRA_FIELD_TYPE = "unixExtraFieldType";
+	const OPTION_STRICTNESS = "strictness";
+	const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
+	const STRICTNESS_STRICT = "strict";
+	const STRICTNESS_BALANCED = "balanced";
+	const STRICTNESS_TOLERANT = "tolerant";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -3738,8 +3783,6 @@
 	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],
@@ -3781,8 +3824,11 @@
 			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$1(zipReader, options, OPTION_STRICTNESS), getOptionValue$1(zipReader, options, OPTION_CHECK_AMBIGUITY));
+			const checkAmbiguity = strictness == STRICTNESS_STRICT;
+			const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
+			const maxAppendedDataSize = getMaxAppendedDataSize(getOptionValue$1(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$1(signatureArray);
@@ -3792,14 +3838,16 @@
 					throw new Error(ERR_EOCDR_NOT_FOUND);
 				}
 			}
+			if (rejectAmbiguousEndOfDirectory && endOfDirectoryReachingEndCount > 1) {
+				throwAmbiguousArchive("multiple end of central directory records");
+			}
 			const endOfDirectoryView = getDataView$1(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$1(zipReader, options, OPTION_CHECK_AMBIGUITY);
-			if (checkAmbiguity && appendedDataOffset != reader.size) {
+			if (reader.size - appendedDataOffset > maxAppendedDataSize) {
 				throwAmbiguousArchive("appended data");
 			}
 			let lastDiskNumber = getUint16(endOfDirectoryView, 4);
@@ -3812,7 +3860,7 @@
 			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$1(endOfDirectoryLocatorArray);
 				if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH &&
 					getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
@@ -3878,14 +3926,22 @@
 					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$1(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$1(directoryArray);
 					}
-					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
-					directoryView = getDataView$1(directoryArray);
 				}
 			}
 			const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset - (reader.lastDiskOffset || 0);
@@ -4027,11 +4083,11 @@
 			const extractPrependedData = getOptionValue$1(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 			const extractAppendedData = getOptionValue$1(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;
 		}
@@ -4142,8 +4198,8 @@
 				extraFieldLength,
 				filenameLength
 			} = localDirectory;
-			const checkAmbiguity = getOptionValue$1(zipEntry, options, OPTION_CHECK_AMBIGUITY);
-			let rawLocalFilename = new Uint8Array();
+			const checkAmbiguity = getStrictness(getOptionValue$1(zipEntry, options, OPTION_STRICTNESS), getOptionValue$1(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);
@@ -4151,7 +4207,7 @@
 			} 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) {
@@ -4178,12 +4234,7 @@
 			}
 			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$1(zipEntry, options, OPTION_SIGNAL);
 			const checkPasswordOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 			let checkOverlappingEntry = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
@@ -4454,7 +4505,6 @@
 			const view = getDataView$1(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++);
@@ -4464,8 +4514,6 @@
 				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 });
@@ -4517,7 +4565,6 @@
 		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;
@@ -4592,26 +4639,133 @@
 		readRanges.set(index, range);
 	}
 
-	async function seekSignature(reader, signature, startOffset, minimumBytes, maximumLength) {
-		const signatureArray = new Uint8Array(4);
-		const signatureView = getDataView$1(signatureArray);
-		setUint32$1(signatureView, 0, signature);
-		const maximumBytes = minimumBytes + maximumLength;
-		return (await seek(minimumBytes)) || await seek(Math.min(maximumBytes, startOffset));
-
-		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 getStrictness(strictness, checkAmbiguity) {
+		if (strictness === UNDEFINED_VALUE) {
+			return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
+		}
+		return strictness;
+	}
+
+	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$1(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$1(signatureArray), 0);
+		}
+		return UNDEFINED_VALUE;
 	}
 
 	function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
@@ -4626,8 +4780,6 @@
 		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 ||
@@ -4676,10 +4828,6 @@
 		return Number(view.getBigUint64(offset, true));
 	}
 
-	function setUint32$1(view, offset, value) {
-		view.setUint32(offset, value, true);
-	}
-
 	function getDataView$1(array) {
 		return new DataView(array.buffer, array.byteOffset, array.byteLength);
 	}
@@ -4721,7 +4869,6 @@
 	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;
@@ -4804,12 +4951,12 @@
 					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;
 				}
@@ -4915,7 +5062,7 @@
 			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;
@@ -5214,7 +5361,7 @@
 		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;
@@ -5275,8 +5422,6 @@
 		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);
 			}
@@ -5287,8 +5432,6 @@
 		}
 		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;
@@ -5426,7 +5569,6 @@
 				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;
@@ -5469,6 +5611,13 @@
 			if (releaseLockWriter) {
 				releaseLockWriter();
 			}
+			if (bufferedWrite && fileWriter && fileWriter.dispose) {
+				try {
+					await fileWriter.dispose();
+				} catch {
+					// ignored
+				}
+			}
 		}
 
 		function requestLockCurrentFileEntry() {
@@ -5488,7 +5637,7 @@
 		async function skipDiskIfNeeded() {
 			if (getLength(headerInfo.localHeaderArray) > writer.availableSize) {
 				writer.availableSize = 0;
-				await writeData(writer, new Uint8Array());
+				await writeData(writer, EMPTY_UINT8_ARRAY);
 			}
 		}
 	}
@@ -5599,8 +5748,7 @@
 		}
 		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: {
@@ -5700,13 +5848,9 @@
 			: 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);
@@ -5720,7 +5864,7 @@
 				}
 			}
 		} else {
-			rawLocalExtraFieldZip64 = new Uint8Array();
+			rawLocalExtraFieldZip64 = EMPTY_UINT8_ARRAY;
 		}
 		let rawExtraFieldAES;
 		if (encrypted && !zipCrypto) {
@@ -5730,7 +5874,7 @@
 			rawExtraFieldAES = extraFieldAES.array;
 			rawExtraFieldAES[8] = encryptionStrength;
 		} else {
-			rawExtraFieldAES = new Uint8Array();
+			rawExtraFieldAES = EMPTY_UINT8_ARRAY;
 		}
 		let rawExtraFieldNTFS;
 		let rawExtraFieldExtendedTimestamp;
@@ -5753,8 +5897,7 @@
 				}
 				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);
@@ -5769,10 +5912,10 @@
 				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 {
@@ -5798,10 +5941,10 @@
 				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;
@@ -5868,7 +6011,7 @@
 			version,
 			compressionMethod,
 			extraFieldExtendedTimestampFlag,
-			rawExtraFieldZip64: new Uint8Array(),
+			rawExtraFieldZip64: EMPTY_UINT8_ARRAY,
 			localExtraFieldZip64Length,
 			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
@@ -5881,7 +6024,6 @@
 	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;
@@ -5894,7 +6036,7 @@
 		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;
@@ -5902,7 +6044,7 @@
 
 	function packUnixId(id) {
 		if (id === UNDEFINED_VALUE) {
-			return new Uint8Array();
+			return EMPTY_UINT8_ARRAY;
 		} else {
 			const dataArray = new Uint8Array(4);
 			const dataView = getDataView(dataArray);
@@ -5945,7 +6087,7 @@
 		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) {
@@ -6029,7 +6171,6 @@
 			}
 		}
 		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));
@@ -6083,7 +6224,7 @@
 				}
 				rawExtraFieldZip64 = extraFieldZip64.array;
 			} else {
-				rawExtraFieldZip64 = new Uint8Array();
+				rawExtraFieldZip64 = EMPTY_UINT8_ARRAY;
 			}
 			fileEntry.rawExtraFieldZip64 = rawExtraFieldZip64;
 			fileEntry.zip64Offset = zip64Offset;
@@ -6098,7 +6239,7 @@
 				extraFieldTimestamp.uint32(lastModTimeUnix);
 				rawExtraFieldTimestamp = extraFieldTimestamp.array;
 			} else {
-				rawExtraFieldTimestamp = new Uint8Array();
+				rawExtraFieldTimestamp = EMPTY_UINT8_ARRAY;
 			}
 			fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
 			const extraFieldLength = getLength(
@@ -6154,7 +6295,7 @@
 				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;
@@ -6227,7 +6368,7 @@
 		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) {
@@ -6324,7 +6465,6 @@
 		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;
 	}
@@ -6506,6 +6646,141 @@
 	 */
 
 
+	const DEFAULT_THRESHOLD = 1024 * 1024;
+	const DEFAULT_DIRECTORY_NAME = ".zip.js-temp";
+
+	function createOPFSTempStream(options = {}) {
+		const {
+			thresholdBytes = DEFAULT_THRESHOLD,
+			directoryName = DEFAULT_DIRECTORY_NAME,
+			getDirectory = () => navigator.storage.getDirectory()
+		} = options;
+		let directoryHandlePromise;
+		function getTempDirectory() {
+			if (!directoryHandlePromise) {
+				directoryHandlePromise = Promise.resolve(getDirectory())
+					.then(root => root.getDirectoryHandle(directoryName, { create: true }));
+			}
+			return directoryHandlePromise;
+		}
+		return function () {
+			const memoryChunks = [];
+			let bufferedSize = 0;
+			let spilled = false;
+			let fileName, fileHandle, fileWriter, fileReader;
+
+			async function spillToFile() {
+				const directoryHandle = await getTempDirectory();
+				fileName = crypto.randomUUID();
+				fileHandle = await directoryHandle.getFileHandle(fileName, { create: true });
+				fileWriter = (await fileHandle.createWritable()).getWriter();
+				spilled = true;
+				for (const chunk of memoryChunks) {
+					await fileWriter.write(chunk);
+				}
+				memoryChunks.length = 0;
+			}
+
+			const writable = new WritableStream({
+				async write(chunk) {
+					if (spilled) {
+						await fileWriter.write(chunk);
+					} else {
+						memoryChunks.push(chunk);
+						bufferedSize += chunk.length;
+						if (bufferedSize > thresholdBytes) {
+							await spillToFile();
+						}
+					}
+				},
+				async close() {
+					if (fileWriter) {
+						await fileWriter.close();
+						fileWriter = null;
+					}
+				}
+			});
+
+			let memoryIndex = 0;
+			const readable = new ReadableStream({
+				async pull(controller) {
+					if (spilled) {
+						if (!fileReader) {
+							const file = await fileHandle.getFile();
+							fileReader = file.stream().getReader();
+						}
+						const { value, done } = await fileReader.read();
+						if (done) {
+							controller.close();
+						} else {
+							controller.enqueue(value);
+						}
+					} else if (memoryIndex < memoryChunks.length) {
+						controller.enqueue(memoryChunks[memoryIndex++]);
+					} else {
+						controller.close();
+					}
+				},
+				async cancel(reason) {
+					if (fileReader) {
+						await fileReader.cancel(reason);
+					}
+				}
+			}, { highWaterMark: 0 });
+			async function dispose() {
+				if (fileWriter) {
+					try {
+						await fileWriter.close();
+					} catch {
+						// ignored
+					}
+					fileWriter = null;
+				}
+				if (fileName) {
+					try {
+						const directoryHandle = await getTempDirectory();
+						await directoryHandle.removeEntry(fileName);
+					} catch {
+						// ignored
+					}
+					fileHandle = fileName = null;
+				}
+				memoryChunks.length = 0;
+			}
+
+			return { writable, readable, dispose };
+		};
+	}
+
+	/*
+	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+	 Redistribution and use in source and binary forms, with or without
+	 modification, are permitted provided that the following conditions are met:
+
+	 1. Redistributions of source code must retain the above copyright notice,
+	 this list of conditions and the following disclaimer.
+
+	 2. Redistributions in binary form must reproduce the above copyright
+	 notice, this list of conditions and the following disclaimer in
+	 the documentation and/or other materials provided with the distribution.
+
+	 3. The names of the authors may not be used to endorse or promote products
+	 derived from this software without specific prior written permission.
+
+	 THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+	 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+	 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+	 INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+	 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+	 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	 */
+
+
 	try {
 		configure({ baseURI: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('zip-core.js', document.baseURI).href)) });
 	} catch {
@@ -6536,6 +6811,7 @@
 	exports.ERR_INVALID_SIGNATURE = ERR_INVALID_SIGNATURE;
 	exports.ERR_INVALID_UNCOMPRESSED_SIZE = ERR_INVALID_UNCOMPRESSED_SIZE;
 	exports.ERR_INVALID_VERSION = ERR_INVALID_VERSION;
+	exports.ERR_ITERATOR_COMPLETED_TOO_SOON = ERR_ITERATOR_COMPLETED_TOO_SOON;
 	exports.ERR_LOCAL_FILE_HEADER_NOT_FOUND = ERR_LOCAL_FILE_HEADER_NOT_FOUND;
 	exports.ERR_OVERLAPPING_ENTRY = ERR_OVERLAPPING_ENTRY;
 	exports.ERR_SPLIT_ZIP_FILE = ERR_SPLIT_ZIP_FILE;
@@ -6544,6 +6820,7 @@
 	exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION$1;
 	exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+	exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;
 	exports.ERR_ZIP_NOT_EMPTY = ERR_ZIP_NOT_EMPTY;
 	exports.HttpRangeReader = HttpRangeReader;
 	exports.HttpReader = HttpReader;
@@ -6560,6 +6837,7 @@
 	exports.ZipWriter = ZipWriter;
 	exports.ZipWriterStream = ZipWriterStream;
 	exports.configure = configure;
+	exports.createOPFSTempStream = createOPFSTempStream;
 	exports.getMimeType = getMimeType;
 	exports.terminateWorkers = terminateWorkers;