@zip.js/zip.js 2.8.34 → 2.8.35

package/lib/core/codec-pool.js

@@ -63,8 +63,8 @@ async function runWorker(stream, workerOptions) {
 	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);

package/lib/core/codec-worker.js

@@ -34,6 +34,7 @@ import {
 	FUNCTION_TYPE
 } from "./constants.js";
 import { getChunkSize } from "./configuration.js";
+import { toExactUint8Array } from "./util/array.js";
 import {
 	CODEC_DEFLATE,
 	CodecStream,
@@ -203,7 +204,10 @@ async function runWorker({ options, readable, writable, onTaskFinished }, config
 			}
 		}
 		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,
@@ -402,7 +406,7 @@ function sendMessage(message, { worker, writer, transferStreams }) {
 		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) {

package/lib/core/configuration.js

@@ -51,6 +51,7 @@ const DEFAULT_CONFIGURATION = {
 	workerStarvationTimeout: 5000,
 	useWebWorkers: true,
 	useCompressionStream: true,
+	transferStreams: true,
 	CompressionStream: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
 	DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 };
@@ -65,16 +66,19 @@ const CONFIGURABLE_PROPERTY_NAMES = [
 	"workerStarvationTimeout",
 	"useCompressionStream",
 	"useWebWorkers",
+	"transferStreams",
 	"CompressionStream",
 	"DecompressionStream",
 	"CompressionStreamZlib",
 	"DecompressionStreamZlib"
 ];
 
-const config = Object.assign({}, DEFAULT_CONFIGURATION);
+const config = { ...DEFAULT_CONFIGURATION };
 
 export {
 	configure,
+	setDefaultConfiguration,
+	resetConfiguration,
 	getConfiguration,
 	getChunkSize
 };
@@ -95,3 +99,20 @@ function configure(configuration) {
 		}
 	}
 }
+
+function setDefaultConfiguration(configuration) {
+	for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
+		const propertyValue = configuration[propertyName];
+		if (propertyValue !== UNDEFINED_VALUE) {
+			DEFAULT_CONFIGURATION[propertyName] = propertyValue;
+		}
+	}
+	configure(configuration);
+}
+
+function resetConfiguration() {
+	for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
+		delete config[propertyName];
+	}
+	Object.assign(config, DEFAULT_CONFIGURATION);
+}

package/lib/core/io.js

@@ -31,15 +31,16 @@
 
 import {
 	UNDEFINED_VALUE,
-	INFINITY_VALUE,
 	FUNCTION_TYPE,
 	END_OF_CENTRAL_DIR_LENGTH,
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
-import { getConfiguration } from "./configuration.js";
+import { getConfiguration, getChunkSize } from "./configuration.js";
+import { concat, toExactUint8Array } from "./util/array.js";
 
 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";
 
@@ -50,13 +51,15 @@ const HTTP_HEADER_CONTENT_RANGE = "Content-Range";
 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 = 64 * 1024;
 const DEFAULT_BUFFER_SIZE = 256 * 1024;
 
 const PROPERTY_NAME_WRITABLE = "writable";
+const DISK_BOUNDARY = Symbol();
 
 class Stream {
 
@@ -75,13 +78,13 @@ class Reader extends Stream {
 		return this.createReadable();
 	}
 
-	createReadable({ offset = 0, size, diskNumberStart, chunkSize = DEFAULT_CHUNK_SIZE } = {}) {
+	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();
@@ -103,7 +106,7 @@ class Writer extends Stream {
 				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, {
@@ -190,6 +193,27 @@ class Data64URIWriter extends Writer {
 	}
 }
 
+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) {
@@ -198,14 +222,32 @@ class BlobReader extends Reader {
 			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);
@@ -286,6 +328,18 @@ class FetchReader extends Reader {
 		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);
 	}
@@ -314,6 +368,7 @@ function createHttpReader(httpReader, url, options) {
 		useRangeHeader,
 		forceRangeRequests,
 		combineSizeEocd,
+		checkResourceChanges = true,
 		fetch
 	} = options;
 	options = Object.assign({}, options);
@@ -321,6 +376,7 @@ function createHttpReader(httpReader, url, options) {
 	delete options.useRangeHeader;
 	delete options.forceRangeRequests;
 	delete options.combineSizeEocd;
+	delete options.checkResourceChanges;
 	delete options.useXHR;
 	delete options.fetch;
 	Object.assign(httpReader, {
@@ -330,6 +386,7 @@ function createHttpReader(httpReader, url, options) {
 		useRangeHeader,
 		forceRangeRequests,
 		combineSizeEocd,
+		checkResourceChanges,
 		fetch
 	});
 }
@@ -354,17 +411,8 @@ async function initHttpReader(httpReader, sendRequest, getRequestData) {
 					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 {
@@ -405,6 +453,8 @@ async function readUint8ArrayHttpReader(httpReader, index, length, sendRequest,
 					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);
@@ -416,7 +466,97 @@ async function readUint8ArrayHttpReader(httpReader, index, length, sendRequest,
 		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 remainingLength = size;
+	return new ReadableStream({
+		async start() {
+			const response = await sendFetchRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, offset, size));
+			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 != offset) {
+					throw new Error(ERR_HTTP_RANGE);
+				}
+			}
+			checkResourceValidators(httpReader, response);
+			setResourceValidators(httpReader, response);
+			bodyReader = response.body.getReader();
+		},
+		async pull(controller) {
+			const { value, done } = await bodyReader.read();
+			if (done) {
+				if (remainingLength) {
+					throw new Error(ERR_HTTP_RANGE);
+				}
+				controller.close();
+			} else {
+				const chunk = value.length > remainingLength ? value.subarray(0, remainingLength) : value;
+				remainingLength -= chunk.length;
+				if (chunk.length) {
+					controller.enqueue(chunk);
+				}
+				if (!remainingLength) {
+					controller.close();
+					await bodyReader.cancel();
+				}
+			}
+		},
+		cancel(reason) {
+			return bodyReader && bodyReader.cancel(reason);
+		}
+	});
+}
+
+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);
+			}
+		}
 	}
 }
 
@@ -527,6 +667,10 @@ class HttpReader extends Reader {
 		super.init();
 	}
 
+	createReadable(options) {
+		return this.reader.createReadable(options);
+	}
+
 	readUint8Array(index, length) {
 		return this.reader.readUint8Array(index, length);
 	}
@@ -607,25 +751,26 @@ class SplitDataReader extends Reader {
 		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;
@@ -638,14 +783,9 @@ class SplitDataReader extends Reader {
 				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;
@@ -670,6 +810,12 @@ class SplitDataWriter extends Stream {
 		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();
@@ -689,11 +835,7 @@ class SplitDataWriter extends Stream {
 					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));
 					}
@@ -704,7 +846,7 @@ class SplitDataWriter extends Stream {
 			async close() {
 				if (diskWriter) {
 					await diskWriter.ready;
-					await closeDisk();
+					await closeDiskWriter();
 				}
 			},
 			async abort(reason) {
@@ -729,10 +871,28 @@ class SplitDataWriter extends Stream {
 			}
 		}
 
-		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 {
@@ -764,14 +924,6 @@ class GenericWriter {
 		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;
 	}
 }
@@ -790,8 +942,8 @@ async function initStream(stream, initSize) {
 	}
 }
 
-function readUint8Array(reader, offset, size, diskNumber) {
-	return reader.readUint8Array(offset, size, diskNumber);
+function readUint8Array(reader, offset, size) {
+	return reader.readUint8Array(offset, size);
 }
 
 export {
@@ -814,6 +966,7 @@ export {
 	SplitDataReader,
 	SplitDataWriter,
 	ERR_HTTP_RANGE,
+	ERR_HTTP_RESOURCE_CHANGED,
 	ERR_ITERATOR_COMPLETED_TOO_SOON,
 	ERR_WRITER_NOT_INITIALIZED
 };

package/lib/core/streams/aes-crypto-stream.js

@@ -31,6 +31,7 @@
 
 import { UNDEFINED_VALUE, UNDEFINED_TYPE, FUNCTION_TYPE, EMPTY_UINT8_ARRAY } from "../constants.js";
 import { encodeText } from "./../util/encode-text.js";
+import { concat } from "./../util/array.js";
 import {
 	cipher,
 	codec,
@@ -291,16 +292,6 @@ function encodePassword(password, rawPassword) {
 	}
 }
 
-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;

package/lib/core/streams/codec-stream.js

@@ -133,33 +133,54 @@ class CodecStream extends TransformStream {
 class ChunkStream extends TransformStream {
 
 	constructor(chunkSize) {
-		let pendingChunk;
+		const pendingChunks = [];
+		let pendingLength = 0;
 		if (!(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;
 		}
 	}
 }