@zip.js/zip.js 2.8.34 → 2.8.36

package/dist/zip-fs-core.js

@@ -161,11 +161,12 @@
 		workerStarvationTimeout: 5000,
 		useWebWorkers: true,
 		useCompressionStream: true,
+		transferStreams: true,
 		CompressionStream: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
 		DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 	};
 
-	const config = Object.assign({}, DEFAULT_CONFIGURATION);
+	const config = { ...DEFAULT_CONFIGURATION };
 
 	function getConfiguration() {
 		return config;
@@ -175,6 +176,50 @@
 		return Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
 	}
 
+	/*
+	 Copyright (c) 2026 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.
+	 */
+
+
+	function concat(first, second) {
+		const result = new Uint8Array(first.length + second.length);
+		result.set(first);
+		result.set(second, first.length);
+		return result;
+	}
+
+	function toExactUint8Array(array) {
+		return array.byteOffset || array.byteLength != array.buffer.byteLength ? new Uint8Array(array) : array;
+	}
+
+	function getDataView(array) {
+		return new DataView(array.buffer, array.byteOffset, array.byteLength);
+	}
+
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -206,6 +251,7 @@
 
 	const ERR_HTTP_STATUS = "HTTP error ";
 	const ERR_HTTP_RANGE = "HTTP Range not supported";
+	const ERR_HTTP_RESOURCE_CHANGED = "HTTP resource changed";
 	const ERR_ITERATOR_COMPLETED_TOO_SOON = "Writer iterator completed too soon";
 	const ERR_WRITER_NOT_INITIALIZED = "Writer not initialized";
 
@@ -216,13 +262,16 @@
 	const HTTP_HEADER_ACCEPT_RANGES = "Accept-Ranges";
 	const HTTP_HEADER_RANGE = "Range";
 	const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
+	const HTTP_HEADER_ETAG = "Etag";
+	const HTTP_HEADER_LAST_MODIFIED = "Last-Modified";
 	const HTTP_METHOD_HEAD = "HEAD";
 	const HTTP_METHOD_GET = "GET";
 	const HTTP_RANGE_UNIT = "bytes";
-	const DEFAULT_CHUNK_SIZE$1 = 64 * 1024;
 	const DEFAULT_BUFFER_SIZE = 256 * 1024;
+	const DEFAULT_MAXIMUM_RANGE_SIZE = 16 * 1024 * 1024;
 
 	const PROPERTY_NAME_WRITABLE = "writable";
+	const DISK_BOUNDARY = Symbol();
 
 	class Stream {
 
@@ -241,13 +290,13 @@
 			return this.createReadable();
 		}
 
-		createReadable({ offset = 0, size, diskNumberStart, chunkSize = DEFAULT_CHUNK_SIZE$1 } = {}) {
+		createReadable({ offset = 0, size, chunkSize = getChunkSize(getConfiguration()) } = {}) {
 			const reader = this;
 			let chunkOffset = 0;
 			return new ReadableStream({
 				async pull(controller) {
 					const dataSize = size === UNDEFINED_VALUE ? chunkSize : Math.min(chunkSize, size - chunkOffset);
-					const data = await readUint8Array(reader, offset + chunkOffset, dataSize, diskNumberStart);
+					const data = await readUint8Array(reader, offset + chunkOffset, dataSize);
 					controller.enqueue(data);
 					if ((chunkOffset + chunkSize > size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
 						controller.close();
@@ -269,7 +318,7 @@
 					if (!writer.initialized) {
 						throw new Error(ERR_WRITER_NOT_INITIALIZED);
 					}
-					return writer.writeUint8Array(chunk);
+					return writer.writeUint8Array(toExactUint8Array(chunk));
 				}
 			});
 			Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
@@ -356,6 +405,27 @@
 		}
 	}
 
+	let blobSliceReliable;
+	let blobSliceProbe;
+
+	function probeBlobSliceReliability() {
+		blobSliceProbe = (async () => {
+			try {
+				const slicedBlob = new Blob([new Uint8Array(3)]).slice(1, 2);
+				const streamReader = slicedBlob.stream().getReader();
+				let streamedLength = 0;
+				let result = await streamReader.read();
+				while (!result.done) {
+					streamedLength += result.value.length;
+					result = await streamReader.read();
+				}
+				blobSliceReliable = streamedLength == 1;
+			} catch {
+				blobSliceReliable = false;
+			}
+		})();
+	}
+
 	class BlobReader extends Reader {
 
 		constructor(blob) {
@@ -364,14 +434,32 @@
 				blob,
 				size: blob.size
 			});
+			if (!blobSliceProbe) {
+				probeBlobSliceReliability();
+			}
+		}
+
+		createReadable(options) {
+			const reader = this;
+			const { blob, size } = reader;
+			const { offset = 0, size: readSize = size - offset } = options || {};
+			if (!offset && readSize >= size) {
+				return blob.stream();
+			}
+			if (blobSliceReliable) {
+				return blob.slice(offset, offset + readSize).stream();
+			}
+			return super.createReadable(options);
 		}
 
 		async readUint8Array(offset, length) {
 			const reader = this;
 			const offsetEnd = offset + length;
-			const blob = offset || offsetEnd < reader.size ? reader.blob.slice(offset, offsetEnd) : reader.blob;
+			const readsWholeBlob = !offset && offsetEnd >= reader.size;
+			const blob = readsWholeBlob ? reader.blob : reader.blob.slice(offset, offsetEnd);
 			let arrayBuffer = await blob.arrayBuffer();
-			if (arrayBuffer.byteLength > length) {
+			const sliceIgnoredByBuggyImplementation = arrayBuffer.byteLength > length;
+			if (sliceIgnoredByBuggyImplementation) {
 				arrayBuffer = arrayBuffer.slice(offset, offsetEnd);
 			}
 			return new Uint8Array(arrayBuffer);
@@ -452,6 +540,18 @@
 			super.init();
 		}
 
+		createReadable(options) {
+			const reader = this;
+			const { useRangeHeader, forceRangeRequests, size } = reader;
+			if ((useRangeHeader || forceRangeRequests) && size !== UNDEFINED_VALUE) {
+				const { offset = 0, size: readSize = size - offset } = options || {};
+				if (readSize > 0 && offset < size) {
+					return createRangeReadable(reader, offset, Math.min(readSize, size - offset));
+				}
+			}
+			return super.createReadable(options);
+		}
+
 		readUint8Array(index, length) {
 			return readUint8ArrayHttpReader(this, index, length, sendFetchRequest, getFetchRequestData);
 		}
@@ -480,6 +580,8 @@
 			useRangeHeader,
 			forceRangeRequests,
 			combineSizeEocd,
+			checkResourceChanges = true,
+			maximumRangeSize = DEFAULT_MAXIMUM_RANGE_SIZE,
 			fetch
 		} = options;
 		options = Object.assign({}, options);
@@ -487,6 +589,8 @@
 		delete options.useRangeHeader;
 		delete options.forceRangeRequests;
 		delete options.combineSizeEocd;
+		delete options.checkResourceChanges;
+		delete options.maximumRangeSize;
 		delete options.useXHR;
 		delete options.fetch;
 		Object.assign(httpReader, {
@@ -496,6 +600,8 @@
 			useRangeHeader,
 			forceRangeRequests,
 			combineSizeEocd,
+			checkResourceChanges,
+			maximumRangeSize,
 			fetch
 		});
 	}
@@ -520,17 +626,8 @@
 						httpReader.eocdCache = eocdCache;
 					}
 				}
-				let contentSize;
-				const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
-				if (contentRangeHeader) {
-					const splitHeader = contentRangeHeader.trim().split(/\s*\/\s*/);
-					if (splitHeader.length) {
-						const headerValue = splitHeader[1];
-						if (headerValue && headerValue != "*") {
-							contentSize = Number(headerValue);
-						}
-					}
-				}
+				setResourceValidators(httpReader, response);
+				const contentSize = getContentRangeSize(response);
 				if (contentSize === UNDEFINED_VALUE) {
 					await getContentLength(httpReader, sendRequest, getRequestData);
 				} else {
@@ -571,6 +668,8 @@
 						throw new Error(ERR_HTTP_RANGE);
 					}
 				}
+				checkResourceValidators(httpReader, response);
+				setResourceValidators(httpReader, response);
 				const data = new Uint8Array(await response.arrayBuffer());
 				if (data.length != length) {
 					throw new Error(ERR_HTTP_RANGE);
@@ -582,7 +681,114 @@
 			if (!data) {
 				await getRequestData(httpReader, options);
 			}
-			return new Uint8Array(httpReader.data.subarray(index, index + length));
+			return httpReader.data.subarray(index, index + length);
+		}
+	}
+
+	function createRangeReadable(httpReader, offset, size) {
+		let bodyReader;
+		let windowOffset = offset;
+		let windowRemainingLength = 0;
+		let remainingLength = size;
+		return new ReadableStream({
+			start() {
+				return openWindow();
+			},
+			async pull(controller) {
+				if (!bodyReader) {
+					await openWindow();
+				}
+				const { value, done } = await bodyReader.read();
+				if (done) {
+					throw new Error(ERR_HTTP_RANGE);
+				}
+				const chunk = value.length > windowRemainingLength ? value.subarray(0, windowRemainingLength) : value;
+				windowRemainingLength -= chunk.length;
+				remainingLength -= chunk.length;
+				if (chunk.length) {
+					controller.enqueue(chunk);
+				}
+				if (!windowRemainingLength) {
+					await closeWindow();
+					if (!remainingLength) {
+						controller.close();
+					}
+				}
+			},
+			cancel(reason) {
+				return bodyReader && bodyReader.cancel(reason);
+			}
+		});
+
+		async function openWindow() {
+			const windowLength = Math.min(httpReader.maximumRangeSize, remainingLength);
+			const response = await sendFetchRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, windowOffset, windowLength));
+			if (response.status != 206) {
+				throw new Error(ERR_HTTP_RANGE);
+			}
+			const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
+			if (contentRangeHeader) {
+				const rangeStart = Number(contentRangeHeader.trim().split(/[\s-]+/)[1]);
+				if (!Number.isNaN(rangeStart) && rangeStart != windowOffset) {
+					throw new Error(ERR_HTTP_RANGE);
+				}
+			}
+			checkResourceValidators(httpReader, response);
+			setResourceValidators(httpReader, response);
+			windowOffset += windowLength;
+			windowRemainingLength = windowLength;
+			bodyReader = response.body.getReader();
+		}
+
+		async function closeWindow() {
+			const currentBodyReader = bodyReader;
+			bodyReader = UNDEFINED_VALUE;
+			await currentBodyReader.cancel();
+		}
+	}
+
+	function getContentRangeSize(response) {
+		const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
+		if (contentRangeHeader) {
+			const headerValue = contentRangeHeader.trim().split(/\s*\/\s*/)[1];
+			if (headerValue && headerValue != "*") {
+				const contentSize = Number(headerValue);
+				if (!Number.isNaN(contentSize)) {
+					return contentSize;
+				}
+			}
+		}
+	}
+
+	function getResourceValidators({ headers }) {
+		return {
+			etag: headers.get(HTTP_HEADER_ETAG) || UNDEFINED_VALUE,
+			lastModified: headers.get(HTTP_HEADER_LAST_MODIFIED) || UNDEFINED_VALUE
+		};
+	}
+
+	function setResourceValidators(httpReader, response) {
+		const { checkResourceChanges, resourceValidators } = httpReader;
+		if (checkResourceChanges && !resourceValidators && response.status == 206) {
+			httpReader.resourceValidators = getResourceValidators(response);
+		}
+	}
+
+	function checkResourceValidators(httpReader, response) {
+		const { checkResourceChanges, resourceValidators, size } = httpReader;
+		if (checkResourceChanges) {
+			const contentRangeSize = getContentRangeSize(response);
+			if (contentRangeSize !== UNDEFINED_VALUE && size !== UNDEFINED_VALUE && contentRangeSize != size) {
+				throw new Error(ERR_HTTP_RESOURCE_CHANGED);
+			}
+			if (resourceValidators) {
+				const validators = getResourceValidators(response);
+				const changed = Object.entries(resourceValidators).some(([name, value]) =>
+					value !== UNDEFINED_VALUE && validators[name] !== UNDEFINED_VALUE && value != validators[name]);
+				if (changed) {
+					throw new Error(ERR_HTTP_RESOURCE_CHANGED);
+				}
+			}
 		}
 	}
 
@@ -693,6 +899,10 @@
 			super.init();
 		}
 
+		createReadable(options) {
+			return this.reader.createReadable(options);
+		}
+
 		readUint8Array(index, length) {
 			return this.reader.readUint8Array(index, length);
 		}
@@ -766,25 +976,26 @@
 			const reader = this;
 			const { readers } = reader;
 			reader.lastDiskNumber = 0;
-			reader.lastDiskOffset = 0;
-			await Promise.all(readers.map(async (diskReader, indexDiskReader) => {
-				await initStream(diskReader);
-				if (indexDiskReader != readers.length - 1) {
-					reader.lastDiskOffset += diskReader.size;
-				}
+			await Promise.all(readers.map(diskReader => initStream(diskReader)));
+			reader.diskOffsets = readers.map(diskReader => {
+				const diskOffset = reader.size;
 				reader.size += diskReader.size;
-			}));
+				return diskOffset;
+			});
 			super.init();
 		}
 
-		async readUint8Array(offset, length, diskNumber = 0) {
+		getDiskOffset(diskNumber) {
+			const { diskOffsets, size } = this;
+			const diskOffset = diskOffsets.at(diskNumber);
+			return diskOffset === UNDEFINED_VALUE ? size : diskOffset;
+		}
+
+		async readUint8Array(offset, length) {
 			const reader = this;
 			const { readers } = this;
 			let result;
-			let currentDiskNumber = diskNumber;
-			if (currentDiskNumber == -1) {
-				currentDiskNumber = readers.length - 1;
-			}
+			let currentDiskNumber = 0;
 			let currentReaderOffset = offset;
 			while (readers[currentDiskNumber] && currentReaderOffset >= readers[currentDiskNumber].size) {
 				currentReaderOffset -= readers[currentDiskNumber].size;
@@ -797,14 +1008,9 @@
 					result = await readUint8Array(currentReader, currentReaderOffset, length);
 				} else {
 					const chunkLength = currentReaderSize - currentReaderOffset;
-					result = new Uint8Array(length);
 					const firstPart = await readUint8Array(currentReader, currentReaderOffset, chunkLength);
-					result.set(firstPart, 0);
-					const secondPart = await reader.readUint8Array(offset + chunkLength, length - chunkLength, diskNumber);
-					result.set(secondPart, chunkLength);
-					if (firstPart.length + secondPart.length < length) {
-						result = result.subarray(0, firstPart.length + secondPart.length);
-					}
+					const secondPart = await reader.readUint8Array(offset + chunkLength, length - chunkLength);
+					result = concat(firstPart, secondPart);
 				}
 			} else {
 				result = EMPTY_UINT8_ARRAY;
@@ -829,6 +1035,12 @@
 			let diskSourceWriter, diskWritable, diskWriter;
 			const writable = new WritableStream({
 				async write(chunk) {
+					if (chunk === DISK_BOUNDARY) {
+						if (diskWriter) {
+							await endDisk();
+						}
+						return;
+					}
 					const { availableSize } = writer;
 					if (!diskWriter) {
 						const { value, done } = await writerGenerator.next();
@@ -848,11 +1060,7 @@
 						await this.write(chunk);
 					} else if (chunk.length >= availableSize) {
 						await writeChunk(chunk.subarray(0, availableSize));
-						await closeDisk();
-						writer.diskOffset += diskSourceWriter.size;
-						writer.diskNumber++;
-						diskWriter = null;
-						writer.availableSize = writer.maxSize;
+						await endDisk();
 						if (chunk.length > availableSize) {
 							await this.write(chunk.subarray(availableSize));
 						}
@@ -863,7 +1071,7 @@
 				async close() {
 					if (diskWriter) {
 						await diskWriter.ready;
-						await closeDisk();
+						await closeDiskWriter();
 					}
 				},
 				async abort(reason) {
@@ -888,10 +1096,28 @@
 				}
 			}
 
-			async function closeDisk() {
+			async function endDisk() {
+				await closeDiskWriter();
+				writer.diskOffset += diskSourceWriter.size;
+				writer.diskNumber++;
+				diskWriter = null;
+				writer.availableSize = writer.maxSize;
+			}
+
+			async function closeDiskWriter() {
 				await diskWriter.close();
 			}
 		}
+
+		async closeDisk() {
+			const streamWriter = this.writable.getWriter();
+			try {
+				await streamWriter.ready;
+				await streamWriter.write(DISK_BOUNDARY);
+			} finally {
+				streamWriter.releaseLock();
+			}
+		}
 	}
 
 	class GenericReader {
@@ -923,14 +1149,6 @@
 			if (writer.size === UNDEFINED_VALUE) {
 				writer.size = 0;
 			}
-			if (!(writer instanceof SplitDataWriter)) {
-				Object.assign(writer, {
-					diskNumber: 0,
-					diskOffset: 0,
-					availableSize: INFINITY_VALUE,
-					maxSize: INFINITY_VALUE
-				});
-			}
 			return writer;
 		}
 	}
@@ -949,8 +1167,8 @@
 		}
 	}
 
-	function readUint8Array(reader, offset, size, diskNumber) {
-		return reader.readUint8Array(offset, size, diskNumber);
+	function readUint8Array(reader, offset, size) {
+		return reader.readUint8Array(offset, size);
 	}
 
 	/*
@@ -2239,16 +2457,6 @@
 		}
 	}
 
-	function concat(leftArray, rightArray) {
-		let array = leftArray;
-		if (leftArray.length + rightArray.length) {
-			array = new Uint8Array(leftArray.length + rightArray.length);
-			array.set(leftArray, 0);
-			array.set(rightArray, leftArray.length);
-		}
-		return array;
-	}
-
 	function expand(inputArray, length) {
 		if (length && length > inputArray.length) {
 			const array = inputArray;
@@ -2510,44 +2718,34 @@
 		constructor() {
 			// deno-lint-ignore prefer-const
 			let stream;
-			let headerLeft = GZIP_HEADER_LENGTH;
-			let tail = new Uint8Array(0);
+			let headerBytesLeft = GZIP_HEADER_LENGTH;
+			let trailerCandidate = new Uint8Array(0);
 			super({
 				transform(chunk, controller) {
-					if (headerLeft) {
-						const dropped = Math.min(headerLeft, chunk.length);
-						headerLeft -= dropped;
-						chunk = chunk.subarray(dropped);
+					if (headerBytesLeft) {
+						const droppedLength = Math.min(headerBytesLeft, chunk.length);
+						headerBytesLeft -= droppedLength;
+						chunk = chunk.subarray(droppedLength);
 						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;
+					const availableLength = trailerCandidate.length + chunk.length;
+					if (availableLength <= GZIP_TRAILER_LENGTH) {
+						trailerCandidate = concat(trailerCandidate, chunk);
 						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;
+					const emitLength = availableLength - GZIP_TRAILER_LENGTH;
+					const emittedFromTrailer = Math.min(emitLength, trailerCandidate.length);
+					controller.enqueue(concat(
+						trailerCandidate.subarray(0, emittedFromTrailer),
+						chunk.subarray(0, emitLength - emittedFromTrailer)));
+					trailerCandidate = concat(
+						trailerCandidate.subarray(emittedFromTrailer),
+						chunk.subarray(emitLength - emittedFromTrailer));
 				},
 				flush() {
-					const dataView = new DataView(tail.buffer, tail.byteOffset, tail.byteLength);
+					const dataView = getDataView(trailerCandidate);
 					stream.signature = dataView.getUint32(0, true);
 					stream.uncompressedSize = dataView.getUint32(4, true);
 				}
@@ -2790,33 +2988,54 @@
 	class ChunkStream extends TransformStream {
 
 		constructor(chunkSize) {
-			let pendingChunk;
-			if (!(chunkSize >= 1)) {
+			const pendingChunks = [];
+			let pendingLength = 0;
+			if (!Number.isFinite(chunkSize) || chunkSize < 1) {
 				chunkSize = DEFAULT_CHUNK_SIZE;
 			}
 			super({
-				transform,
+				transform(chunk, controller) {
+					pendingChunks.push(chunk);
+					pendingLength += chunk.length;
+					while (pendingLength > chunkSize) {
+						controller.enqueue(shiftChunk());
+					}
+				},
 				flush(controller) {
-					if (pendingChunk && pendingChunk.length) {
-						controller.enqueue(pendingChunk);
+					if (pendingLength) {
+						controller.enqueue(concatChunks(pendingChunks, pendingLength));
 					}
 				}
 			});
 
-			function transform(chunk, controller) {
-				if (pendingChunk) {
-					const newChunk = new Uint8Array(pendingChunk.length + chunk.length);
-					newChunk.set(pendingChunk);
-					newChunk.set(chunk, pendingChunk.length);
-					chunk = newChunk;
-					pendingChunk = null;
+			function shiftChunk() {
+				const result = new Uint8Array(chunkSize);
+				let resultOffset = 0;
+				while (resultOffset < chunkSize) {
+					const firstChunk = pendingChunks[0];
+					const remainingLength = chunkSize - resultOffset;
+					if (firstChunk.length <= remainingLength) {
+						result.set(firstChunk, resultOffset);
+						resultOffset += firstChunk.length;
+						pendingChunks.shift();
+					} else {
+						result.set(firstChunk.subarray(0, remainingLength), resultOffset);
+						pendingChunks[0] = firstChunk.subarray(remainingLength);
+						resultOffset += remainingLength;
+					}
 				}
+				pendingLength -= chunkSize;
+				return result;
+			}
+
+			function concatChunks(chunks, length) {
+				const result = new Uint8Array(length);
 				let offset = 0;
-				while (chunk.length - offset > chunkSize) {
-					controller.enqueue(chunk.slice(offset, offset + chunkSize));
-					offset += chunkSize;
+				for (const chunk of chunks) {
+					result.set(chunk, offset);
+					offset += chunk.length;
 				}
-				pendingChunk = offset ? chunk.slice(offset) : chunk;
+				return result;
 			}
 		}
 	}
@@ -2998,7 +3217,10 @@
 				}
 			}
 			codecStream = new CodecStream(options, config);
-			await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
+			await readable
+				.pipeThrough(codecStream)
+				.pipeThrough(new ChunkStream(getChunkSize(config)))
+				.pipeTo(writable, { preventClose: true, preventAbort: true });
 			const {
 				signature,
 				inputSize,
@@ -3197,7 +3419,7 @@
 			const { value, readable, writable } = message;
 			const transferables = [];
 			if (value) {
-				message.value = value.byteOffset || value.byteLength != value.buffer.byteLength ? new Uint8Array(value) : value;
+				message.value = toExactUint8Array(value);
 				transferables.push(message.value.buffer);
 			}
 			if (transferStreams && transferStreamsSupported) {
@@ -3321,8 +3543,8 @@
 		const { options, config } = workerOptions;
 		const { transferStreams, useWebWorkers, useCompressionStream, compressed, signed, encrypted } = options;
 		const { workerURI, maxWorkers } = config;
-		workerOptions.transferStreams = transferStreams || transferStreams === UNDEFINED_VALUE;
-		const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
+		workerOptions.transferStreams = transferStreams || (transferStreams === UNDEFINED_VALUE && config.transferStreams);
+		const streamCopy = !compressed && !signed && !encrypted;
 		workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 		workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
 		options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
@@ -3791,7 +4013,7 @@
 			const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
 			if (!endOfDirectoryInfo) {
 				const signatureArray = await readUint8Array(reader, 0, 4);
-				const signatureView = getDataView$1(signatureArray);
+				const signatureView = getDataView(signatureArray);
 				if (getUint32(signatureView) == SPLIT_ZIP_FILE_SIGNATURE) {
 					throw new Error(ERR_SPLIT_ZIP_FILE);
 				} else {
@@ -3801,7 +4023,7 @@
 			if (rejectAmbiguousEndOfDirectory && endOfDirectoryReachingEndCount > 1) {
 				throwAmbiguousArchive("multiple end of central directory records");
 			}
-			const endOfDirectoryView = getDataView$1(endOfDirectoryInfo);
+			const endOfDirectoryView = getDataView(endOfDirectoryInfo);
 			let directoryDataLength = getUint32(endOfDirectoryView, 12);
 			let directoryDataOffset = getUint32(endOfDirectoryView, 16);
 			const commentOffset = endOfDirectoryInfo.offset;
@@ -3817,17 +4039,21 @@
 			let prependedDataLength = 0;
 			let startOffset;
 			let zip64EndOfDirectory;
-			if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS) {
+			const requiresZip64 = directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS;
+			if (directoryDataOffset != MAX_32_BITS && diskNumber != MAX_16_BITS) {
+				directoryDataOffset += getDiskOffset$1(reader, diskNumber);
+			}
+			if (requiresZip64) {
 				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) :
 					EMPTY_UINT8_ARRAY;
-				const endOfDirectoryLocatorView = getDataView$1(endOfDirectoryLocatorArray);
+				const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
 				if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH &&
 					getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
-					directoryDataOffset = getBigUint64(endOfDirectoryLocatorView, 8);
-					let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
-					let endOfDirectoryView = getDataView$1(endOfDirectoryArray);
-					const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH - (reader.lastDiskOffset || 0);
+					directoryDataOffset = getDiskOffset$1(reader, getUint32(endOfDirectoryLocatorView, 4)) + getBigUint64(endOfDirectoryLocatorView, 8);
+					let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+					let endOfDirectoryView = getDataView(endOfDirectoryArray);
+					const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 					if ((endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) &&
 						directoryDataOffset != expectedDirectoryDataOffset && expectedDirectoryDataOffset >= 0) {
 						const originalDirectoryDataOffset = directoryDataOffset;
@@ -3835,8 +4061,8 @@
 						if (directoryDataOffset > originalDirectoryDataOffset) {
 							prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
 						}
-						endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
-						endOfDirectoryView = getDataView$1(endOfDirectoryArray);
+						endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+						endOfDirectoryView = getDataView(endOfDirectoryArray);
 					}
 					if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
 						throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
@@ -3862,7 +4088,7 @@
 					} else if (checkAmbiguity && directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
 						throwAmbiguousArchive("mismatched zip64 end of central directory record");
 					}
-					directoryDataOffset = getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
+					directoryDataOffset = getDiskOffset$1(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 				}
 			}
 			const declaredDirectoryDataLength = directoryDataLength;
@@ -3879,19 +4105,19 @@
 				throw new Error(ERR_BAD_FORMAT);
 			}
 			let offset = 0;
-			let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
-			let directoryView = getDataView$1(directoryArray);
+			let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+			let directoryView = getDataView(directoryArray);
 			if (directoryDataLength) {
 				if (directoryArray.length < 4) {
 					throw new Error(ERR_BAD_FORMAT);
 				}
-				const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength - (reader.lastDiskOffset || 0);
+				const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 				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;
+						const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4);
+						reconcile = getUint32(getDataView(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
 					}
 					if (reconcile) {
 						const originalDirectoryDataOffset = directoryDataOffset;
@@ -3899,16 +4125,16 @@
 						if (directoryDataOffset > originalDirectoryDataOffset) {
 							prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
 						}
-						directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
-						directoryView = getDataView$1(directoryArray);
+						directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+						directoryView = getDataView(directoryArray);
 					}
 				}
 			}
-			const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset - (reader.lastDiskOffset || 0);
+			const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset;
 			if (directoryDataLength != expectedDirectoryDataLength && expectedDirectoryDataLength >= 0 && diskNumber == lastDiskNumber) {
 				directoryDataLength = expectedDirectoryDataLength;
-				directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
-				directoryView = getDataView$1(directoryArray);
+				directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+				directoryView = getDataView(directoryArray);
 			}
 			if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 				throw new Error(ERR_BAD_FORMAT);
@@ -3981,7 +4207,7 @@
 				});
 				readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
 				fileEntry.offset += prependedDataLength;
-				startOffset = Math.min(fileEntry.offset, startOffset);
+				startOffset = Math.min(getDiskOffset$1(reader, fileEntry.diskNumberStart) + fileEntry.offset, startOffset);
 				if (checkAmbiguity) {
 					if (filenames.has(fileEntry.filename)) {
 						duplicateFilename = true;
@@ -4095,8 +4321,9 @@
 				dataDescriptor
 			} = bitFlag;
 			const localDirectory = fileEntry.localDirectory = {};
-			const dataArray = await readUint8Array(reader, offset, HEADER_SIZE, diskNumberStart);
-			const dataView = getDataView$1(dataArray);
+			const localHeaderOffset = getDiskOffset$1(reader, diskNumberStart) + offset;
+			const dataArray = await readUint8Array(reader, localHeaderOffset, HEADER_SIZE);
+			const dataView = getDataView(dataArray);
 			let password = getOptionValue$1(zipEntry, options, OPTION_PASSWORD);
 			let rawPassword = getOptionValue$1(zipEntry, options, OPTION_RAW_PASSWORD);
 			const passThrough = getOptionValue$1(zipEntry, options, OPTION_PASS_THROUGH);
@@ -4121,12 +4348,12 @@
 			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);
+				const trailingDataArray = await readUint8Array(reader, localHeaderOffset + HEADER_SIZE, filenameLength + extraFieldLength);
 				rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
 				localDirectory.rawExtraField = trailingDataArray.subarray(filenameLength);
 			} else {
 				localDirectory.rawExtraField = extraFieldLength ?
-					await readUint8Array(reader, offset + HEADER_SIZE + filenameLength, extraFieldLength, diskNumberStart) :
+					await readUint8Array(reader, localHeaderOffset + HEADER_SIZE + filenameLength, extraFieldLength) :
 					EMPTY_UINT8_ARRAY;
 			}
 			readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
@@ -4152,9 +4379,9 @@
 					throw new Error(ERR_ENCRYPTED);
 				}
 			}
-			const dataOffset = offset + HEADER_SIZE + filenameLength + extraFieldLength;
+			const dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
 			const size = compressedSize;
-			const readable = reader.createReadable({ offset: dataOffset, size, diskNumberStart, chunkSize: getChunkSize(config) });
+			const readable = reader.createReadable({ offset: dataOffset, size });
 			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);
@@ -4195,8 +4422,7 @@
 					reader,
 					fileEntry,
 					index,
-					offset,
-					diskNumberStart,
+					offset: localHeaderOffset,
 					signature,
 					compressedSize,
 					uncompressedSize,
@@ -4260,7 +4486,7 @@
 	function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory) {
 		const { rawExtraField } = directory;
 		const extraField = directory.extraField = new Map();
-		const rawExtraFieldView = getDataView$1(new Uint8Array(rawExtraField));
+		const rawExtraFieldView = getDataView(rawExtraField);
 		let offsetExtraField = 0;
 		try {
 			while (offsetExtraField < rawExtraField.length) {
@@ -4332,7 +4558,7 @@
 
 	function readExtraFieldZip64(extraFieldZip64, directory) {
 		directory.zip64 = true;
-		const extraFieldView = getDataView$1(extraFieldZip64.data);
+		const extraFieldView = getDataView(extraFieldZip64.data);
 		const missingProperties = ZIP64_PROPERTIES.filter(([propertyName, max]) => directory[propertyName] == max);
 		const requiredLength = missingProperties.reduce((length, [, max]) => length + ZIP64_EXTRACTION[max].bytes, 0);
 		if (extraFieldZip64.data.length < requiredLength) {
@@ -4351,10 +4577,10 @@
 			extraFieldUnicode.valid = false;
 			return;
 		}
-		const extraFieldView = getDataView$1(extraFieldUnicode.data);
+		const extraFieldView = getDataView(extraFieldUnicode.data);
 		const crc32 = new Crc32();
 		crc32.append(fileEntry[rawPropertyName]);
-		const dataViewSignature = getDataView$1(new Uint8Array(4));
+		const dataViewSignature = getDataView(new Uint8Array(4));
 		dataViewSignature.setUint32(0, crc32.get(), true);
 		const signature = getUint32(extraFieldView, 1);
 		Object.assign(extraFieldUnicode, {
@@ -4369,7 +4595,7 @@
 	}
 
 	function readExtraFieldAES(extraFieldAES, directory, compressionMethod) {
-		const extraFieldView = getDataView$1(extraFieldAES.data);
+		const extraFieldView = getDataView(extraFieldAES.data);
 		const strength = getUint8(extraFieldView, 4);
 		Object.assign(extraFieldAES, {
 			vendorVersion: getUint8(extraFieldView, 0),
@@ -4382,7 +4608,7 @@
 	}
 
 	function readExtraFieldNTFS(extraFieldNTFS, directory) {
-		const extraFieldView = getDataView$1(extraFieldNTFS.data);
+		const extraFieldView = getDataView(extraFieldNTFS.data);
 		let offsetExtraField = 4;
 		let tag1Data;
 		try {
@@ -4399,7 +4625,7 @@
 		}
 		try {
 			if (tag1Data && tag1Data.length == 24) {
-				const tag1View = getDataView$1(tag1Data);
+				const tag1View = getDataView(tag1Data);
 				const rawLastModDate = tag1View.getBigUint64(0, true);
 				const rawLastAccessDate = tag1View.getBigUint64(8, true);
 				const rawCreationDate = tag1View.getBigUint64(16, true);
@@ -4422,7 +4648,7 @@
 
 	function readExtraFieldUnix(extraField, directory, isInfoZip) {
 		try {
-			const view = getDataView$1(new Uint8Array(extraField.data));
+			const view = getDataView(extraField.data);
 			let uid, gid;
 			if (isInfoZip) {
 				let offset = 0;
@@ -4460,7 +4686,7 @@
 		if (!extraFieldExtendedTimestamp.data.length) {
 			return;
 		}
-		const extraFieldView = getDataView$1(extraFieldExtendedTimestamp.data);
+		const extraFieldView = getDataView(extraFieldExtendedTimestamp.data);
 		const flags = getUint8(extraFieldView, 0);
 		const timeProperties = [];
 		const timeRawProperties = [];
@@ -4498,7 +4724,6 @@
 		fileEntry,
 		index,
 		offset,
-		diskNumberStart,
 		signature,
 		compressedSize,
 		uncompressedSize,
@@ -4507,12 +4732,6 @@
 		extraFieldZip64,
 		readRanges
 	}) {
-		let diskOffset = 0;
-		if (diskNumberStart && reader.readers) {
-			for (let indexReader = 0; indexReader < Math.min(diskNumberStart, reader.readers.length); indexReader++) {
-				diskOffset += reader.readers[indexReader].size;
-			}
-		}
 		let dataDescriptorLength = 0;
 		if (dataDescriptor) {
 			if (extraFieldZip64) {
@@ -4522,19 +4741,19 @@
 			}
 		}
 		if (dataDescriptorLength) {
-			const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, diskNumberStart);
+			const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
 			const dataDescriptorSignature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
-				getUint32(getDataView$1(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
+				getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
 			if (dataDescriptorSignature) {
-				const readSignature = getUint32(getDataView$1(dataDescriptorArray), 4);
+				const readSignature = getUint32(getDataView(dataDescriptorArray), 4);
 				let readCompressedSize;
 				let readUncompressedSize;
 				if (extraFieldZip64) {
-					readCompressedSize = getBigUint64(getDataView$1(dataDescriptorArray), 8);
-					readUncompressedSize = getBigUint64(getDataView$1(dataDescriptorArray), 16);
+					readCompressedSize = getBigUint64(getDataView(dataDescriptorArray), 8);
+					readUncompressedSize = getBigUint64(getDataView(dataDescriptorArray), 16);
 				} else {
-					readCompressedSize = getUint32(getDataView$1(dataDescriptorArray), 8);
-					readUncompressedSize = getUint32(getDataView$1(dataDescriptorArray), 12);
+					readCompressedSize = getUint32(getDataView(dataDescriptorArray), 8);
+					readUncompressedSize = getUint32(getDataView(dataDescriptorArray), 12);
 				}
 				const matchSignature = (fileEntry.encrypted && !fileEntry.zipCrypto) || readSignature == signature;
 				if (matchSignature &&
@@ -4545,8 +4764,8 @@
 			}
 		}
 		const range = {
-			start: diskOffset + offset,
-			end: diskOffset + dataOffset + compressedSize + dataDescriptorLength,
+			start: offset,
+			end: dataOffset + compressedSize + dataDescriptorLength,
 			fileEntry
 		};
 		for (const [otherIndex, otherRange] of readRanges) {
@@ -4559,6 +4778,10 @@
 		readRanges.set(index, range);
 	}
 
+	function getDiskOffset$1(reader, diskNumber) {
+		return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
+	}
+
 	function getStrictness(strictness, checkAmbiguity) {
 		if (strictness === UNDEFINED_VALUE) {
 			return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
@@ -4642,7 +4865,7 @@
 	async function* scanEndOfCentralDirectory(reader, scanLength) {
 		const scanOffset = reader.size - scanLength;
 		const scanArray = await readUint8Array(reader, scanOffset, scanLength);
-		const scanView = getDataView$1(scanArray);
+		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];
@@ -4665,7 +4888,8 @@
 		if (!filesLength && !directoryDataLength) {
 			return CENTRAL_DIRECTORY_PLAUSIBLE;
 		}
-		for (const centralDirectoryOffset of [offset - directoryDataLength, directoryDataOffset]) {
+		const directoryDiskNumber = getUint16(view, indexByte + 6);
+		for (const centralDirectoryOffset of [offset - directoryDataLength, getDiskOffset$1(reader, directoryDiskNumber) + directoryDataOffset]) {
 			if (await readSignature(reader, view, anchoredOffset, centralDirectoryOffset, size, remoteProbeBudget) == CENTRAL_FILE_HEADER_SIGNATURE) {
 				return CENTRAL_DIRECTORY_REACHABLE;
 			}
@@ -4683,7 +4907,7 @@
 		if (remoteProbeBudget.count > 0) {
 			remoteProbeBudget.count--;
 			const signatureArray = await readUint8Array(reader, signatureOffset, 4);
-			return getUint32(getDataView$1(signatureArray), 0);
+			return getUint32(getDataView(signatureArray), 0);
 		}
 		return UNDEFINED_VALUE;
 	}
@@ -4748,9 +4972,26 @@
 		return Number(view.getBigUint64(offset, true));
 	}
 
-	function getDataView$1(array) {
-		return new DataView(array.buffer, array.byteOffset, array.byteLength);
-	}
+	var zipReader = /*#__PURE__*/Object.freeze({
+		__proto__: null,
+		ERR_AMBIGUOUS_ARCHIVE: ERR_AMBIGUOUS_ARCHIVE,
+		ERR_BAD_FORMAT: ERR_BAD_FORMAT,
+		ERR_CENTRAL_DIRECTORY_NOT_FOUND: ERR_CENTRAL_DIRECTORY_NOT_FOUND,
+		ERR_ENCRYPTED: ERR_ENCRYPTED,
+		ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND: ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND,
+		ERR_EOCDR_NOT_FOUND: ERR_EOCDR_NOT_FOUND,
+		ERR_EXTRAFIELD_ZIP64_NOT_FOUND: ERR_EXTRAFIELD_ZIP64_NOT_FOUND,
+		ERR_INVALID_COMPRESSED_DATA: ERR_INVALID_COMPRESSED_DATA,
+		ERR_INVALID_PASSWORD: ERR_INVALID_PASSWORD,
+		ERR_INVALID_SIGNATURE: ERR_INVALID_SIGNATURE,
+		ERR_INVALID_UNCOMPRESSED_SIZE: ERR_INVALID_UNCOMPRESSED_SIZE,
+		ERR_LOCAL_FILE_HEADER_NOT_FOUND: ERR_LOCAL_FILE_HEADER_NOT_FOUND,
+		ERR_OVERLAPPING_ENTRY: ERR_OVERLAPPING_ENTRY,
+		ERR_SPLIT_ZIP_FILE: ERR_SPLIT_ZIP_FILE,
+		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
+		ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
+		ZipReader: ZipReader
+	});
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -4815,9 +5056,10 @@
 
 		constructor(writer, options = {}) {
 			writer = new GenericWriter(writer);
+			const { availableSize = INFINITY_VALUE, maxSize = INFINITY_VALUE } = writer;
 			const addSplitZipSignature =
-				writer.availableSize !== UNDEFINED_VALUE && writer.availableSize > 0 && writer.availableSize !== INFINITY_VALUE &&
-				writer.maxSize !== UNDEFINED_VALUE && writer.maxSize > 0 && writer.maxSize !== INFINITY_VALUE;
+				availableSize > 0 && availableSize !== INFINITY_VALUE &&
+				maxSize > 0 && maxSize !== INFINITY_VALUE;
 			Object.assign(this, {
 				writer,
 				addSplitZipSignature,
@@ -4839,9 +5081,10 @@
 			}
 			reader = new GenericReader(reader);
 			await initStream(reader);
-			const zipReader = new ZipReader(reader.readable);
-			const entries = await zipReader.getEntries();
-			await zipReader.close();
+			const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
+			const zipReader$1 = new ZipReader(reader.readable);
+			const entries = await zipReader$1.getEntries();
+			await zipReader$1.close();
 			await initStream(this.writer);
 			await reader.readable.pipeTo(this.writer.writable, { preventClose: true, preventAbort: true });
 			this.writer.size = this.offset = reader.size;
@@ -4857,8 +5100,6 @@
 					encrypted,
 					uncompressedSize,
 					compressedSize,
-					diskOffset,
-					diskNumber,
 					zip64
 				} = entry;
 				let {
@@ -4906,8 +5147,9 @@
 				Object.assign(entry, {
 					zip64UncompressedSize,
 					zip64CompressedSize,
-					zip64Offset: zip64 && this.offset - diskOffset >= MAX_32_BITS,
-					zip64DiskNumberStart: zip64 && diskNumber >= MAX_16_BITS,
+					zip64Offset: zip64 && entry.offset >= MAX_32_BITS,
+					diskNumberStart: 0,
+					zip64DiskNumberStart: false,
 					rawExtraFieldZip64,
 					rawExtraFieldAES,
 					rawExtraFieldExtendedTimestamp,
@@ -5012,7 +5254,8 @@
 		try {
 			const sizesInfo = await resolveSizes(zipWriter, reader, metadataInfo, options);
 			({ reader } = sizesInfo);
-			const { diskOffset, diskNumber } = zipWriter.writer;
+			const diskOffset = getDiskOffset(zipWriter.writer);
+			const diskNumber = getDiskNumber(zipWriter.writer);
 			options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
 				internalFileAttribute: metadataInfo.resolvedOptions.internalFileAttributes,
 				externalFileAttribute: attributesInfo.resolvedOptions.externalFileAttributes,
@@ -5189,7 +5432,7 @@
 		const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
 		const keepOrder = getOptionValue(zipWriter, options, OPTION_KEEP_ORDER, true);
 		const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
-		const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS, true);
+		const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS);
 		const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
 		const createTempStream = getOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 		const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
@@ -5387,7 +5630,7 @@
 				await requestLockWriter();
 			}
 			await initStream(fileWriter);
-			const { diskOffset } = writer;
+			const diskOffset = getDiskOffset(writer);
 			if (zipWriter.addSplitZipSignature) {
 				delete zipWriter.addSplitZipSignature;
 				const signatureArray = new Uint8Array(4);
@@ -5404,7 +5647,7 @@
 				await lockPreviousFileEntry;
 				await skipDiskIfNeeded();
 			}
-			const diskNumberStart = writer.diskNumber;
+			const diskNumberStart = getDiskNumber(writer);
 			const entryOffset = getSegmentOffset(zipWriter, writer);
 			fileEntry.diskNumberStart = diskNumberStart;
 			if (!bufferedWrite) {
@@ -5424,11 +5667,11 @@
 				writingBufferedEntryData = true;
 				writerSizeBeforeEntry = writer.size;
 				await skipDiskIfNeeded();
-				fileEntry.diskNumberStart = writer.diskNumber;
+				fileEntry.diskNumberStart = getDiskNumber(writer);
 				fileEntry.offset = getSegmentOffset(zipWriter, writer);
 				if (usdz) {
 					const previousMetadataSize = entryInfo.metadataSize;
-					appendExtraFieldUSDZ(entryInfo, zipWriter.offset - writer.diskOffset);
+					appendExtraFieldUSDZ(entryInfo, zipWriter.offset - getDiskOffset(writer));
 					fileEntry.size += entryInfo.metadataSize - previousMetadataSize;
 				}
 				updateLocalHeader(fileEntry, headerInfo.localHeaderView, options);
@@ -5493,9 +5736,8 @@
 		}
 
 		async function skipDiskIfNeeded() {
-			if (getLength(headerInfo.localHeaderArray) > writer.availableSize) {
-				writer.availableSize = 0;
-				await writeData(writer, EMPTY_UINT8_ARRAY);
+			if (exceedsAvailableSize(writer, getLength(headerInfo.localHeaderArray))) {
+				await writer.closeDisk();
 			}
 		}
 	}
@@ -5606,7 +5848,7 @@
 		}
 		const { writable } = writer;
 		if (reader) {
-			const readable = reader.createReadable ? reader.createReadable({ chunkSize: getChunkSize(config) }) : reader.readable;
+			const readable = reader.createReadable ? reader.createReadable() : reader.readable;
 			const size = reader.size;
 			const workerOptions = {
 				options: {
@@ -6038,8 +6280,8 @@
 
 	async function closeFile(zipWriter, comment, options) {
 		const directoryDataLength = createDirectoryRecords(zipWriter.files);
-		const { cdStartDiskNumber, cdStartDiskOffset } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
-		await writeEndOfDirectoryRecord(zipWriter, comment, options, { cdStartDiskNumber, cdStartDiskOffset, directoryDataLength });
+		const directoryStart = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+		await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength });
 	}
 
 	function createDirectoryRecords(files) {
@@ -6121,8 +6363,8 @@
 		await initStream(writer);
 		let offset = 0;
 		let directoryDiskOffset = 0;
-		let cdStartDiskNumber = writer.diskNumber;
-		let cdStartDiskOffset = writer.diskOffset;
+		let directoryStartDiskNumber = getDiskNumber(writer);
+		let directoryStartDiskOffset = getDiskOffset(writer);
 		for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
 			const {
 				offset: fileEntryOffset,
@@ -6149,15 +6391,14 @@
 			} = fileEntry;
 			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
 			const directoryRecordLength = CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
-			if (offset + directoryRecordLength - directoryDiskOffset > writer.availableSize) {
+			if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 				await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
 				directoryDiskOffset = offset;
-				writer.availableSize = 0;
-				await writeData(writer, EMPTY_UINT8_ARRAY);
+				await writer.closeDisk();
 			}
 			if (indexFileEntry == 0) {
-				cdStartDiskNumber = writer.diskNumber;
-				cdStartDiskOffset = writer.diskOffset;
+				directoryStartDiskNumber = getDiskNumber(writer);
+				directoryStartDiskOffset = getDiskOffset(writer);
 			}
 			if (!zip64UncompressedSize) {
 				setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, uncompressedSize);
@@ -6197,18 +6438,18 @@
 			}
 		}
 		await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
-		return { cdStartDiskNumber, cdStartDiskOffset };
+		return { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset };
 	}
 
 	async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		const { writer } = zipWriter;
-		const { cdStartDiskNumber, cdStartDiskOffset } = cdInfo;
+		const { directoryStart } = cdInfo;
 		let { directoryDataLength } = cdInfo;
 		let filesLength = zipWriter.files.size;
-		let diskNumber = cdStartDiskNumber;
-		let directoryOffset = zipWriter.offset - cdStartDiskOffset - (cdStartDiskNumber ? zipWriter.initialOffset : 0);
-		let lastDiskNumber = writer.diskNumber;
-		if (writer.availableSize < END_OF_CENTRAL_DIR_LENGTH) {
+		let diskNumber = directoryStart.diskNumber;
+		let directoryOffset = getSegmentOffset(zipWriter, directoryStart);
+		let lastDiskNumber = getDiskNumber(writer);
+		if (exceedsAvailableSize(writer, END_OF_CENTRAL_DIR_LENGTH)) {
 			lastDiskNumber++;
 		}
 		let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
@@ -6224,11 +6465,10 @@
 			throw new Error(ERR_INVALID_COMMENT);
 		}
 		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, EMPTY_UINT8_ARRAY);
+		if (exceedsAvailableSize(writer, getLength(endOfdirectoryRecord.array) + commentLength)) {
+			await writer.closeDisk();
 		}
-		lastDiskNumber = writer.diskNumber;
+		lastDiskNumber = getDiskNumber(writer);
 		if (zip64) {
 			endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
 			endOfdirectoryRecord.uint64(44);
@@ -6242,7 +6482,7 @@
 			endOfdirectoryRecord.uint64(directoryOffset);
 			endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
 			endOfdirectoryRecord.uint32(lastDiskNumber);
-			endOfdirectoryRecord.uint64(BigInt(zipWriter.offset) + BigInt(directoryDataLength) - BigInt(writer.diskOffset) - BigInt(writer.diskNumber ? zipWriter.initialOffset : 0));
+			endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength));
 			endOfdirectoryRecord.uint32(lastDiskNumber + 1);
 			const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 			if (supportZip64SplitFile) {
@@ -6282,8 +6522,23 @@
 		};
 	}
 
-	function getSegmentOffset(zipWriter, writer) {
-		return zipWriter.offset - writer.diskOffset - (writer.diskNumber ? zipWriter.initialOffset : 0);
+	function getDiskNumber(writer) {
+		const { diskNumber = 0 } = writer;
+		return diskNumber;
+	}
+
+	function getDiskOffset(writer) {
+		const { diskOffset = 0 } = writer;
+		return diskOffset;
+	}
+
+	function exceedsAvailableSize(writer, length) {
+		const { availableSize = INFINITY_VALUE } = writer;
+		return length > availableSize;
+	}
+
+	function getSegmentOffset(zipWriter, { diskNumber = 0, diskOffset = 0 }) {
+		return zipWriter.offset - diskOffset - (diskNumber ? zipWriter.initialOffset : 0);
 	}
 
 	async function writeData(writer, array) {
@@ -6360,9 +6615,6 @@
 		array.set(typedArray, offset);
 	}
 
-	function getDataView(array) {
-		return new DataView(array.buffer, array.byteOffset, array.byteLength);
-	}
 
 	function getLength(...arrayLikes) {
 		let result = 0;
@@ -6620,9 +6872,7 @@
 
 		async getArrayBuffer(options) {
 			const array = await this.getUint8Array(options);
-			return array.byteOffset || array.byteLength != array.buffer.byteLength
-				? array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength)
-				: array.buffer;
+			return toExactUint8Array(array).buffer;
 		}
 
 		replaceBlob(blob) {