@zip.js/zip.js 2.6.26 → 2.6.28

package/lib/core/streams/zip-entry-stream.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global CompressionStream, DecompressionStream, TransformStream */
+/* global TransformStream */
 
 import { Crc32Stream } from "./crc32-stream.js";
 import {
@@ -35,51 +35,36 @@ import {
 } from "./aes-crypto-stream.js";
 import {
 	ZipCryptoEncryptionStream,
-	ZipCryptoDecryptionStream,
+	ZipCryptoDecryptionStream
 } from "./zip-crypto-stream.js";
 import {
-	ERR_INVALID_PASSWORD
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE
 } from "./common-crypto.js";
-import { CodecStream } from "./codec-stream.js";
 
-const ERR_INVALID_SIGNATURE = "Invalid signature";
 const COMPRESSION_FORMAT = "deflate-raw";
-const UNDEFINED_TYPE = "undefined";
-const COMPRESSION_STREAM_API_SUPPORTED = typeof CompressionStream == UNDEFINED_TYPE;
-const DECOMPRESSION_STREAM_API_SUPPORTED = typeof DecompressionStream == UNDEFINED_TYPE;
-let INFLATE_RAW_SUPPORTED = true;
-let DEFLATE_RAW_SUPPORTED = true;
 
 class DeflateStream extends TransformStream {
 
-	constructor(codecConstructor, options, { chunkSize }, ...strategies) {
-		super({}, ...strategies);
+	constructor(options, { chunkSize, CompressionStream, CompressionStreamNative }) {
+		super({});
 		const { compressed, encrypted, useCompressionStream, password, passwordVerification, encryptionStrength, zipCrypto, signed, level } = options;
 		const stream = this;
 		let crc32Stream, encryptionStream;
 		let readable = filterEmptyChunks(super.readable);
 		if ((!encrypted || zipCrypto) && signed) {
 			[readable, crc32Stream] = readable.tee();
-			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+			crc32Stream = pipeThrough(crc32Stream, new Crc32Stream());
 		}
 		if (compressed) {
-			if ((useCompressionStream !== undefined && !useCompressionStream) || (COMPRESSION_STREAM_API_SUPPORTED && !DEFLATE_RAW_SUPPORTED)) {
-				readable = pipeCodecStream(codecConstructor, readable, { chunkSize, level });
-			} else {
-				try {
-					readable = readable.pipeThrough(new CompressionStream(COMPRESSION_FORMAT));
-				} catch (_error) {
-					DEFLATE_RAW_SUPPORTED = false;
-					readable = pipeCodecStream(codecConstructor, readable, { chunkSize, level });
-				}
-			}
+			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStreamNative, CompressionStream);
 		}
 		if (encrypted) {
 			if (zipCrypto) {
-				readable = readable.pipeThrough(new ZipCryptoEncryptionStream(password, passwordVerification));
+				readable = pipeThrough(readable, new ZipCryptoEncryptionStream(password, passwordVerification));
 			} else {
 				encryptionStream = new AESEncryptionStream(password, encryptionStrength);
-				readable = readable.pipeThrough(encryptionStream);
+				readable = pipeThrough(readable, encryptionStream);
 			}
 		}
 		setReadable(stream, readable, async () => {
@@ -98,46 +83,31 @@ class DeflateStream extends TransformStream {
 
 class InflateStream extends TransformStream {
 
-	constructor(codecConstructor, options, { chunkSize }, ...strategies) {
-		super({}, ...strategies);
-		const { zipCrypto, encrypted, password, passwordVerification, signed, encryptionStrength, compressed, useCompressionStream } = options;
-		const stream = this;
+	constructor(options, { chunkSize, DecompressionStream, DecompressionStreamNative }) {
+		super({});
+		const { zipCrypto, encrypted, password, passwordVerification, signed, signature, encryptionStrength, compressed, useCompressionStream } = options;
 		let crc32Stream, decryptionStream;
 		let readable = filterEmptyChunks(super.readable);
 		if (encrypted) {
 			if (zipCrypto) {
-				readable = readable.pipeThrough(new ZipCryptoDecryptionStream(password, passwordVerification));
+				readable = pipeThrough(readable, new ZipCryptoDecryptionStream(password, passwordVerification));
 			} else {
 				decryptionStream = new AESDecryptionStream(password, signed, encryptionStrength);
-				readable = readable.pipeThrough(decryptionStream);
+				readable = pipeThrough(readable, decryptionStream);
 			}
 		}
 		if (compressed) {
-			if ((useCompressionStream !== undefined && !useCompressionStream) || (DECOMPRESSION_STREAM_API_SUPPORTED && !INFLATE_RAW_SUPPORTED)) {
-				readable = pipeCodecStream(codecConstructor, readable, { chunkSize });
-			} else {
-				try {
-					readable = readable.pipeThrough(new DecompressionStream(COMPRESSION_FORMAT));
-				} catch (_error) {
-					INFLATE_RAW_SUPPORTED = false;
-					readable = pipeCodecStream(codecConstructor, readable, { chunkSize });
-				}
-			}
+			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize }, DecompressionStreamNative, DecompressionStream);
 		}
 		if ((!encrypted || zipCrypto) && signed) {
 			[readable, crc32Stream] = readable.tee();
-			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+			crc32Stream = pipeThrough(crc32Stream, new Crc32Stream());
 		}
-		setReadable(stream, readable, async () => {
-			if (encrypted && !zipCrypto) {
-				if (!decryptionStream.valid) {
-					throw new Error(ERR_INVALID_SIGNATURE);
-				}
-			}
+		setReadable(this, readable, async () => {
 			if ((!encrypted || zipCrypto) && signed) {
-				const signature = await crc32Stream.getReader().read();
-				const dataViewSignature = new DataView(signature.value.buffer);
-				if (options.signature != dataViewSignature.getUint32(0, false)) {
+				const streamSignature = await crc32Stream.getReader().read();
+				const dataViewSignature = new DataView(streamSignature.value.buffer);
+				if (signature != dataViewSignature.getUint32(0, false)) {
 					throw new Error(ERR_INVALID_SIGNATURE);
 				}
 			}
@@ -152,12 +122,8 @@ export {
 	ERR_INVALID_SIGNATURE
 };
 
-function pipeCodecStream(codecConstructor, readable, options) {
-	return readable.pipeThrough(new CodecStream(codecConstructor, options));
-}
-
 function filterEmptyChunks(readable) {
-	return readable.pipeThrough(new TransformStream({
+	return pipeThrough(readable, new TransformStream({
 		transform(chunk, controller) {
 			if (chunk && chunk.length) {
 				controller.enqueue(chunk);
@@ -167,10 +133,28 @@ function filterEmptyChunks(readable) {
 }
 
 function setReadable(stream, readable, flush) {
-	readable = readable.pipeThrough(new TransformStream({ flush }));
+	readable = pipeThrough(readable, new TransformStream({ flush }));
 	Object.defineProperty(stream, "readable", {
 		get() {
 			return readable;
 		}
 	});
+}
+
+function pipeThroughCommpressionStream(readable, useCompressionStream, options, CodecStreamNative, CodecStream) {
+	try {
+		const CompressionStream = useCompressionStream && CodecStreamNative ? CodecStreamNative : CodecStream;
+		readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options));
+	} catch (error) {
+		if (useCompressionStream) {
+			readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
+		} else {
+			throw error;
+		}
+	}
+	return readable;
+}
+
+function pipeThrough(readable, transformStream) {
+	return readable.pipeThrough(transformStream);
 }

package/lib/core/z-worker-core.js

@@ -30,8 +30,7 @@
 
 import {
 	Codec,
-	CODEC_DEFLATE,
-	CODEC_INFLATE,
+	getCodecStreamClass,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -70,18 +69,19 @@ addEventListener(MESSAGE_EVENT_TYPE, async event => {
 async function init(message) {
 	try {
 		const { options, scripts, config } = message;
-		const { codecType } = options;
 		if (scripts && scripts.length) {
 			importScripts.apply(undefined, scripts);
 		}
 		if (self.initCodec) {
 			self.initCodec();
 		}
-		let codecConstructor;
-		if (codecType.startsWith(CODEC_DEFLATE)) {
-			codecConstructor = self.Deflate;
-		} else if (codecType.startsWith(CODEC_INFLATE)) {
-			codecConstructor = self.Inflate;
+		config.CompressionStreamNative = self.CompressionStream;
+		config.DecompressionStreamNative = self.DecompressionStream;
+		if (self.Deflate) {
+			config.CompressionStream = getCodecStreamClass(self.Deflate);
+		}
+		if (self.Inflate) {
+			config.DecompressionStream = getCodecStreamClass(self.Inflate);
 		}
 		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
 		const readable = message.readable || new ReadableStream({
@@ -106,7 +106,7 @@ async function init(message) {
 				await ackData;
 			}
 		}, strategy);
-		codec = new Codec(codecConstructor, readable, writable, options, config);
+		codec = new Codec(readable, writable, options, config);
 		const result = await codec.run();
 		if (message.writable && !options.preventClose) {
 			await message.writable.close();

package/lib/core/zip-reader.js

@@ -355,8 +355,7 @@ class ZipEntry {
 				preventClose
 			},
 			config,
-			streamOptions: { signal, size, onstart, onprogress, onend },
-			codecConstructor: config.Inflate
+			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
 		writable.size += (await runWorker({ readable, writable }, workerOptions)).size;
 		if (!preventClose) {

package/lib/core/zip-writer.js

@@ -181,12 +181,12 @@ async function addFile(zipWriter, name, reader, options) {
 		options.directory = name.endsWith(DIRECTORY_SIGNATURE);
 	}
 	const rawFilename = encodeText(name);
-	if (rawFilename.length > MAX_16_BITS) {
+	if (getLength(rawFilename) > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_ENTRY_NAME);
 	}
 	const comment = options.comment || "";
 	const rawComment = encodeText(comment);
-	if (rawComment.length > MAX_16_BITS) {
+	if (getLength(rawComment) > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_ENTRY_COMMENT);
 	}
 	const version = zipWriter.options.version || options.version || 0;
@@ -211,19 +211,19 @@ async function addFile(zipWriter, name, reader, options) {
 	if (extraField) {
 		let extraFieldSize = 0;
 		let offset = 0;
-		extraField.forEach(data => extraFieldSize += 4 + data.length);
+		extraField.forEach(data => extraFieldSize += 4 + getLength(data));
 		rawExtraField = new Uint8Array(extraFieldSize);
 		extraField.forEach((data, type) => {
 			if (type > MAX_16_BITS) {
 				throw new Error(ERR_INVALID_EXTRAFIELD_TYPE);
 			}
-			if (data.length > MAX_16_BITS) {
+			if (getLength(data) > MAX_16_BITS) {
 				throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 			}
 			arraySet(rawExtraField, new Uint16Array([type]), offset);
-			arraySet(rawExtraField, new Uint16Array([data.length]), offset + 2);
+			arraySet(rawExtraField, new Uint16Array([getLength(data)]), offset + 2);
 			arraySet(rawExtraField, data, offset + 4);
-			offset += 4 + data.length;
+			offset += 4 + getLength(data);
 		});
 	}
 	let extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp");
@@ -312,7 +312,7 @@ async function addFile(zipWriter, name, reader, options) {
 	});
 	const headerInfo = getHeaderInfo(options);
 	const dataDescriptorInfo = getDataDescriptorInfo(options);
-	maximumEntrySize = headerInfo.localHeaderArray.length + maximumCompressedSize + dataDescriptorInfo.dataDescriptorArray.length;
+	maximumEntrySize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray) + maximumCompressedSize;
 	zipWriter.pendingEntriesSize += maximumEntrySize;
 	let fileEntry;
 	try {
@@ -530,8 +530,7 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 				transferStreams: false
 			},
 			config,
-			streamOptions: { signal, size, onstart, onprogress, onend },
-			codecConstructor: config.Deflate
+			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
 		const result = await runWorker({ readable, writable }, workerOptions);
 		writable.size += result.size;
@@ -562,7 +561,7 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 		creationDate,
 		lastAccessDate,
 		encrypted,
-		length: localHeaderArray.length + compressedSize + dataDescriptorArray.length,
+		length: getLength(localHeaderArray, dataDescriptorArray) + compressedSize,
 		compressionMethod,
 		version,
 		headerArray,
@@ -589,10 +588,10 @@ function getHeaderInfo(options) {
 	} = options;
 	let version = options.version || VERSION_DEFLATE;
 	const compressed = level !== 0 && !directory;
-	const encrypted = Boolean(password && password.length);
+	const encrypted = Boolean(password && getLength(password));
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
-		rawExtraFieldAES = new Uint8Array(EXTRAFIELD_DATA_AES.length + 2);
+		rawExtraFieldAES = new Uint8Array(getLength(EXTRAFIELD_DATA_AES) + 2);
 		const extraFieldAESView = getDataView(rawExtraFieldAES);
 		setUint16(extraFieldAESView, 0, EXTRAFIELD_TYPE_AES);
 		arraySet(rawExtraFieldAES, EXTRAFIELD_DATA_AES, 2);
@@ -606,7 +605,7 @@ function getHeaderInfo(options) {
 		rawExtraFieldExtendedTimestamp = new Uint8Array(9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0));
 		const extraFieldExtendedTimestampView = getDataView(rawExtraFieldExtendedTimestamp);
 		setUint16(extraFieldExtendedTimestampView, 0, EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-		setUint16(extraFieldExtendedTimestampView, 2, rawExtraFieldExtendedTimestamp.length - 4);
+		setUint16(extraFieldExtendedTimestampView, 2, getLength(rawExtraFieldExtendedTimestamp) - 4);
 		const extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
 		setUint8(extraFieldExtendedTimestampView, 4, extraFieldExtendedTimestampFlag);
 		setUint32(extraFieldExtendedTimestampView, 5, Math.floor(options.lastModDate.getTime() / 1000));
@@ -673,18 +672,18 @@ function getHeaderInfo(options) {
 	setUint16(dateView, 2, ((((lastModDate.getFullYear() - 1980) << 4) | (lastModDate.getMonth() + 1)) << 5) | lastModDate.getDate());
 	const rawLastModDate = dateArray[0];
 	setUint32(headerView, 6, rawLastModDate);
-	setUint16(headerView, 22, rawFilename.length);
-	const extraFieldLength = rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length + rawExtraField.length;
+	setUint16(headerView, 22, getLength(rawFilename));
+	const extraFieldLength = getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
 	setUint16(headerView, 24, extraFieldLength);
-	const localHeaderArray = new Uint8Array(30 + rawFilename.length + extraFieldLength);
+	const localHeaderArray = new Uint8Array(30 + getLength(rawFilename) + extraFieldLength);
 	const localHeaderView = getDataView(localHeaderArray);
 	setUint32(localHeaderView, 0, LOCAL_FILE_HEADER_SIGNATURE);
 	arraySet(localHeaderArray, headerArray, 4);
 	arraySet(localHeaderArray, rawFilename, 30);
-	arraySet(localHeaderArray, rawExtraFieldAES, 30 + rawFilename.length);
-	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, 30 + rawFilename.length + rawExtraFieldAES.length);
-	arraySet(localHeaderArray, rawExtraFieldNTFS, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length);
-	arraySet(localHeaderArray, rawExtraField, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
+	arraySet(localHeaderArray, rawExtraFieldAES, 30 + getLength(rawFilename));
+	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, 30 + getLength(rawFilename, rawExtraFieldAES));
+	arraySet(localHeaderArray, rawExtraFieldNTFS, 30 + getLength(rawFilename, rawExtraFieldAES, rawExtraFieldExtendedTimestamp));
+	arraySet(localHeaderArray, rawExtraField, 30 + getLength(rawFilename, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS));
 	return {
 		localHeaderArray,
 		headerArray,
@@ -782,13 +781,14 @@ async function closeFile(zipWriter, comment, options) {
 	let filesLength = files.size;
 	for (const [, fileEntry] of files) {
 		directoryDataLength += 46 +
-			fileEntry.rawFilename.length +
-			fileEntry.rawComment.length +
-			fileEntry.rawExtraFieldZip64.length +
-			fileEntry.rawExtraFieldAES.length +
-			fileEntry.rawExtraFieldExtendedTimestamp.length +
-			fileEntry.rawExtraFieldNTFS.length +
-			fileEntry.rawExtraField.length;
+			getLength(
+				fileEntry.rawFilename,
+				fileEntry.rawComment,
+				fileEntry.rawExtraFieldZip64,
+				fileEntry.rawExtraFieldAES,
+				fileEntry.rawExtraFieldExtendedTimestamp,
+				fileEntry.rawExtraFieldNTFS,
+				fileEntry.rawExtraField);
 	}
 	let zip64 = options.zip64 || zipWriter.options.zip64 || false;
 	if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || filesLength >= MAX_16_BITS) {
@@ -822,18 +822,18 @@ async function closeFile(zipWriter, comment, options) {
 			rawExtraFieldExtendedTimestamp = new Uint8Array(9);
 			const extraFieldExtendedTimestampView = getDataView(rawExtraFieldExtendedTimestamp);
 			setUint16(extraFieldExtendedTimestampView, 0, EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-			setUint16(extraFieldExtendedTimestampView, 2, rawExtraFieldExtendedTimestamp.length - 4);
+			setUint16(extraFieldExtendedTimestampView, 2, getLength(rawExtraFieldExtendedTimestamp) - 4);
 			setUint8(extraFieldExtendedTimestampView, 4, 0x1);
 			setUint32(extraFieldExtendedTimestampView, 5, Math.floor(fileEntry.lastModDate.getTime() / 1000));
 		} else {
 			rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 		}
-		const extraFieldLength = rawExtraFieldZip64.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length + rawExtraField.length;
+		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
 		setUint32(directoryView, offset, CENTRAL_FILE_HEADER_SIGNATURE);
 		setUint16(directoryView, offset + 4, versionMadeBy);
 		arraySet(directoryArray, headerArray, offset + 6);
 		setUint16(directoryView, offset + 30, extraFieldLength);
-		setUint16(directoryView, offset + 32, rawComment.length);
+		setUint16(directoryView, offset + 32, getLength(rawComment));
 		setUint16(directoryView, offset + 36, internalFileAttribute);
 		if (externalFileAttribute) {
 			setUint32(directoryView, offset + 38, externalFileAttribute);
@@ -846,13 +846,13 @@ async function closeFile(zipWriter, comment, options) {
 			setUint32(directoryView, offset + 42, fileEntry.offset);
 		}
 		arraySet(directoryArray, rawFilename, offset + 46);
-		arraySet(directoryArray, rawExtraFieldZip64, offset + 46 + rawFilename.length);
-		arraySet(directoryArray, rawExtraFieldAES, offset + 46 + rawFilename.length + rawExtraFieldZip64.length);
-		arraySet(directoryArray, rawExtraFieldExtendedTimestamp, offset + 46 + rawFilename.length + rawExtraFieldZip64.length + rawExtraFieldAES.length);
-		arraySet(directoryArray, rawExtraFieldNTFS, offset + 46 + rawFilename.length + rawExtraFieldZip64.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length);
-		arraySet(directoryArray, rawExtraField, offset + 46 + rawFilename.length + rawExtraFieldZip64.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
-		arraySet(directoryArray, rawComment, offset + 46 + rawFilename.length + extraFieldLength);
-		offset += 46 + rawFilename.length + extraFieldLength + rawComment.length;
+		arraySet(directoryArray, rawExtraFieldZip64, offset + 46 + getLength(rawFilename));
+		arraySet(directoryArray, rawExtraFieldAES, offset + 46 + getLength(rawFilename, rawExtraFieldZip64));
+		arraySet(directoryArray, rawExtraFieldExtendedTimestamp, offset + 46 + getLength(rawFilename, rawExtraFieldZip64, rawExtraFieldAES));
+		arraySet(directoryArray, rawExtraFieldNTFS, offset + 46 + getLength(rawFilename, rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp));
+		arraySet(directoryArray, rawExtraField, offset + 46 + getLength(rawFilename, rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS));
+		arraySet(directoryArray, rawComment, offset + 46 + getLength(rawFilename) + extraFieldLength);
+		offset += 46 + getLength(rawFilename, rawComment) + extraFieldLength;
 		if (options.onprogress) {
 			try {
 				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
@@ -883,9 +883,10 @@ async function closeFile(zipWriter, comment, options) {
 	setUint16(directoryView, offset + 10, filesLength);
 	setUint32(directoryView, offset + 12, directoryDataLength);
 	setUint32(directoryView, offset + 16, directoryOffset);
-	if (comment && comment.length) {
-		if (comment.length <= MAX_16_BITS) {
-			setUint16(directoryView, offset + 20, comment.length);
+	const commentLength = getLength(comment);
+	if (commentLength) {
+		if (commentLength <= MAX_16_BITS) {
+			setUint16(directoryView, offset + 20, commentLength);
 		} else {
 			throw new Error(ERR_INVALID_COMMENT);
 		}
@@ -893,7 +894,7 @@ async function closeFile(zipWriter, comment, options) {
 	const { writable } = zipWriter.writer;
 	await initStream(zipWriter.writer);
 	await writeData(writable, directoryArray);
-	if (comment && comment.length) {
+	if (commentLength) {
 		await writeData(writable, comment);
 	}
 }
@@ -909,7 +910,7 @@ function sliceAsArrayBuffer(blob, start, end) {
 async function writeData(writable, array) {
 	const streamWriter = writable.getWriter();
 	await streamWriter.ready;
-	writable.size += array.length;
+	writable.size += getLength(array);
 	await streamWriter.write(array);
 	streamWriter.releaseLock();
 }
@@ -950,4 +951,10 @@ function arraySet(array, typedArray, offset) {
 
 function getDataView(array) {
 	return new DataView(array.buffer);
+}
+
+function getLength(...arrayLikes) {
+	let result = 0;
+	arrayLikes.forEach(arrayLike => arrayLike && (result += arrayLike.length));
+	return result;
 }